diff --git a/project/MultiNode.scala b/project/MultiNode.scala
index e767d716d4..767d25fdc4 100644
--- a/project/MultiNode.scala
+++ b/project/MultiNode.scala
@@ -1,5 +1,6 @@
 package akka
 
+import akka.TestExtras.Filter
 import akka.TestExtras.Filter.Keys._
 import com.typesafe.sbt.{SbtScalariform, SbtMultiJvm}
 import sbt._
@@ -8,9 +9,7 @@ import sbt.Keys._
 import com.typesafe.sbt.SbtScalariform.ScalariformKeys
 
 object MultiNode {
-  def executeMultiJvmTests = Def.setting {
-    onlyTestTags.value.contains("long-running") || !excludeTestTags.value.contains("long-running")
-  }
+  def executeMultiJvmTests = Filter.containsOrNotExcludesTag("long-running")
 
   val multiNodeEnabled = sys.props.get("akka.test.multi-node").getOrElse("false").toBoolean
 
@@ -46,27 +45,33 @@ object MultiNode {
     ScalariformKeys.preferences in MultiJvm := Formatting.formattingPreferences) ++
     Option(System.getProperty("akka.test.multi-node.hostsFileName")).map(x => Seq(multiNodeHostsFileName in MultiJvm := x)).getOrElse(Seq.empty) ++
     Option(System.getProperty("akka.test.multi-node.java")).map(x => Seq(multiNodeJavaName in MultiJvm := x)).getOrElse(Seq.empty) ++
-    Option(System.getProperty("akka.test.multi-node.targetDirName")).map(x => Seq(multiNodeTargetDirName in MultiJvm := x)).getOrElse(Seq.empty) ++ {
-    Seq(
-      executeTests in Test := {
-        if (executeMultiJvmTests.value) {
-          val testResults = (executeTests in Test).value
-          val multiNodeResults = multiNodeEnabled match {
-            case true => (multiNodeExecuteTests in MultiJvm).value
-            case false => (executeTests in MultiJvm).value
-          }
-
-          val overall =
-            if (testResults.overall.id < multiNodeResults.overall.id)
-              multiNodeResults.overall
-            else
-              testResults.overall
-          Tests.Output(overall,
-            testResults.events ++ multiNodeResults.events,
-            testResults.summaries ++ multiNodeResults.summaries)
+    Option(System.getProperty("akka.test.multi-node.targetDirName")).map(x => Seq(multiNodeTargetDirName in MultiJvm := x)).getOrElse(Seq.empty) ++
+    ((executeMultiJvmTests, multiNodeEnabled) match {
+      case (true, true) =>
+        executeTests in Test <<= (executeTests in Test, multiNodeExecuteTests in MultiJvm) map {
+          case (testResults, multiNodeResults)  =>
+            val overall =
+              if (testResults.overall.id < multiNodeResults.overall.id)
+                multiNodeResults.overall
+              else
+                testResults.overall
+            Tests.Output(overall,
+              testResults.events ++ multiNodeResults.events,
+              testResults.summaries ++ multiNodeResults.summaries)
         }
-        else (executeTests in Test).value
-      }
-    )
-  }
+      case (true, false) =>
+        executeTests in Test <<= (executeTests in Test, executeTests in MultiJvm) map {
+          case (testResults, multiNodeResults)  =>
+            val overall =
+              if (testResults.overall.id < multiNodeResults.overall.id)
+                multiNodeResults.overall
+              else
+                testResults.overall
+            Tests.Output(overall,
+              testResults.events ++ multiNodeResults.events,
+              testResults.summaries ++ multiNodeResults.summaries)
+        }
+      case (false, _) => Seq.empty
+    })
+
 }
diff --git a/project/TestExtras.scala b/project/TestExtras.scala
index e193e8c013..7708668b47 100644
--- a/project/TestExtras.scala
+++ b/project/TestExtras.scala
@@ -226,14 +226,20 @@ object TestExtras {
 
     import Keys._
 
+    private[Filter] object Params {
+      val testNamesExclude = systemPropertyAsSeq("akka.test.names.exclude").toSet
+      val testTagsExlcude = systemPropertyAsSeq("akka.test.tags.exclude").toSet
+      val testTagsOnly = systemPropertyAsSeq("akka.test.tags.only").toSet
+    }
+
     def settings = {
       Seq(
-        excludeTestNames := systemPropertyAsSeq("akka.test.names.exclude").toSet,
+        excludeTestNames := Params.testNamesExclude,
         excludeTestTags := {
-          if (onlyTestTags.value.isEmpty) systemPropertyAsSeq("akka.test.tags.exclude").toSet
+          if (onlyTestTags.value.isEmpty) Params.testTagsExlcude
           else Set.empty
         },
-        onlyTestTags := systemPropertyAsSeq("akka.test.tags.only").toSet,
+        onlyTestTags := Params.testTagsOnly,
 
         // add filters for tests excluded by name
         testOptions in Test <++= excludeTestNames map { _.toSeq.map(exclude => Tests.Filter(test => !test.contains(exclude))) },
@@ -250,6 +256,10 @@ object TestExtras {
       )
     }
 
+    def containsOrNotExcludesTag(tag: String) = {
+      Params.testTagsOnly.contains(tag) || !Params.testTagsExlcude(tag)
+    }
+
     def systemPropertyAsSeq(name: String): Seq[String] = {
       val prop = sys.props.get(name).getOrElse("")
       if (prop.isEmpty) Seq.empty else prop.split(",").toSeq