diff --git a/akka-cluster/src/main/scala/akka/cluster/Cluster.scala b/akka-cluster/src/main/scala/akka/cluster/Cluster.scala
index 8beb7f4164..0b2b3919f7 100644
--- a/akka-cluster/src/main/scala/akka/cluster/Cluster.scala
+++ b/akka-cluster/src/main/scala/akka/cluster/Cluster.scala
@@ -879,7 +879,6 @@ class Cluster(system: ExtendedActorSystem) extends Extension { clusterNode ⇒
 
       val localGossip = localState.latestGossip
       val localOverview = localGossip.overview
-      val localSeen = localOverview.seen
       val localMembers = localGossip.members
       val localUnreachableMembers = localGossip.overview.unreachable
 
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/ClientDowningNodeThatIsUnreachableSpec.scala b/akka-cluster/src/multi-jvm/scala/akka/cluster/ClientDowningNodeThatIsUnreachableSpec.scala
index ba34c9b0be..b241899ad6 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/ClientDowningNodeThatIsUnreachableSpec.scala
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/ClientDowningNodeThatIsUnreachableSpec.scala
@@ -4,7 +4,6 @@
 package akka.cluster
 
 import com.typesafe.config.ConfigFactory
-import org.scalatest.BeforeAndAfter
 import akka.remote.testkit.MultiNodeConfig
 import akka.remote.testkit.MultiNodeSpec
 import akka.testkit._
@@ -44,7 +43,6 @@ class ClientDowningNodeThatIsUnreachableSpec
 
         // kill 'third' node
         testConductor.shutdown(third, 0)
-        testConductor.removeNode(third)
 
         // mark 'third' node as DOWN
         cluster.down(thirdAddress)
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/ClientDowningNodeThatIsUpSpec.scala b/akka-cluster/src/multi-jvm/scala/akka/cluster/ClientDowningNodeThatIsUpSpec.scala
index ac1d68c8af..ff048a2eda 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/ClientDowningNodeThatIsUpSpec.scala
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/ClientDowningNodeThatIsUpSpec.scala
@@ -4,7 +4,6 @@
 package akka.cluster
 
 import com.typesafe.config.ConfigFactory
-import org.scalatest.BeforeAndAfter
 import akka.remote.testkit.MultiNodeConfig
 import akka.remote.testkit.MultiNodeSpec
 import akka.testkit._
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/ConvergenceSpec.scala b/akka-cluster/src/multi-jvm/scala/akka/cluster/ConvergenceSpec.scala
new file mode 100644
index 0000000000..a76083b0fc
--- /dev/null
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/ConvergenceSpec.scala
@@ -0,0 +1,129 @@
+/**
+ *  Copyright (C) 2009-2012 Typesafe Inc. <http://www.typesafe.com>
+ */
+package akka.cluster
+
+import com.typesafe.config.ConfigFactory
+import akka.remote.testkit.MultiNodeConfig
+import akka.remote.testkit.MultiNodeSpec
+import akka.testkit._
+import akka.util.duration._
+import akka.actor.Address
+
+object ConvergenceMultiJvmSpec extends MultiNodeConfig {
+  val first = role("first")
+  val second = role("second")
+  val third = role("third")
+  val fourth = role("fourth")
+
+  commonConfig(debugConfig(on = false).
+    withFallback(ConfigFactory.parseString("""
+      akka.cluster {
+        failure-detector.threshold = 4
+      }
+    """)).
+    withFallback(MultiNodeClusterSpec.clusterConfig))
+}
+
+class ConvergenceMultiJvmNode1 extends ConvergenceSpec
+class ConvergenceMultiJvmNode2 extends ConvergenceSpec
+class ConvergenceMultiJvmNode3 extends ConvergenceSpec
+class ConvergenceMultiJvmNode4 extends ConvergenceSpec
+
+abstract class ConvergenceSpec
+  extends MultiNodeSpec(ConvergenceMultiJvmSpec)
+  with MultiNodeClusterSpec {
+  import ConvergenceMultiJvmSpec._
+
+  override def initialParticipants = 4
+
+  "A cluster of 3 members" must {
+
+    "reach initial convergence" taggedAs LongRunningTest in {
+      runOn(first) {
+        cluster.self
+        awaitUpConvergence(numberOfMembers = 3)
+      }
+
+      runOn(second, third) {
+        cluster.join(node(first).address)
+        awaitUpConvergence(numberOfMembers = 3)
+      }
+
+      runOn(fourth) {
+        // doesn't join immediately
+      }
+
+      testConductor.enter("after-1")
+    }
+
+    "not reach convergence while any nodes are unreachable" taggedAs LongRunningTest in {
+      val thirdAddress = node(third).address
+      testConductor.enter("before-shutdown")
+
+      runOn(first) {
+        // kill 'third' node
+        testConductor.shutdown(third, 0)
+      }
+
+      runOn(first, second) {
+        val firstAddress = node(first).address
+        val secondAddress = node(second).address
+
+        within(25 seconds) {
+          // third becomes unreachable
+          awaitCond(cluster.latestGossip.overview.unreachable.size == 1)
+          awaitCond(cluster.latestGossip.members.size == 2)
+          awaitCond(cluster.latestGossip.members.forall(_.status == MemberStatus.Up))
+          awaitSeenSameState(Seq(firstAddress, secondAddress))
+          // still one unreachable
+          cluster.latestGossip.overview.unreachable.size must be(1)
+          cluster.latestGossip.overview.unreachable.head.address must be(thirdAddress)
+          // and therefore no convergence
+          cluster.convergence.isDefined must be(false)
+
+        }
+      }
+
+      testConductor.enter("after-2")
+    }
+
+    "not move a new joining node to Up while there is no convergence" taggedAs LongRunningTest in {
+      runOn(fourth) {
+        // try to join
+        cluster.join(node(first).address)
+      }
+
+      val firstAddress = node(first).address
+      val secondAddress = node(second).address
+      val fourthAddress = node(fourth).address
+
+      def memberStatus(address: Address): Option[MemberStatus] =
+        cluster.latestGossip.members.collectFirst { case m if m.address == address ⇒ m.status }
+
+      def assertNotMovedUp: Unit = {
+        within(20 seconds) {
+          awaitCond(cluster.latestGossip.members.size == 3)
+          awaitSeenSameState(Seq(firstAddress, secondAddress, fourthAddress))
+          memberStatus(firstAddress) must be(Some(MemberStatus.Up))
+          memberStatus(secondAddress) must be(Some(MemberStatus.Up))
+          // leader is not allowed to move the new node to Up
+          memberStatus(fourthAddress) must be(Some(MemberStatus.Joining))
+          // still no convergence
+          cluster.convergence.isDefined must be(false)
+        }
+      }
+
+      runOn(first, second, fourth) {
+        for (n ← 1 to 5) {
+          log.debug("assertNotMovedUp#" + n)
+          assertNotMovedUp
+          // wait and then check again
+          1.second.dilated.sleep
+        }
+      }
+
+      testConductor.enter("after-3")
+    }
+  }
+}
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/GossipingAccrualFailureDetectorSpec.scala b/akka-cluster/src/multi-jvm/scala/akka/cluster/GossipingAccrualFailureDetectorSpec.scala
index cec99e9af9..27a012d32e 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/GossipingAccrualFailureDetectorSpec.scala
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/GossipingAccrualFailureDetectorSpec.scala
@@ -3,7 +3,6 @@
  */
 package akka.cluster
 
-import org.scalatest.BeforeAndAfter
 import com.typesafe.config.ConfigFactory
 import akka.remote.testkit.MultiNodeConfig
 import akka.remote.testkit.MultiNodeSpec
@@ -16,7 +15,7 @@ object GossipingAccrualFailureDetectorMultiJvmSpec extends MultiNodeConfig {
   val third = role("third")
 
   commonConfig(debugConfig(on = false).
-    withFallback(ConfigFactory.parseString("akka.cluster.failure-detector.threshold=4")).
+    withFallback(ConfigFactory.parseString("akka.cluster.failure-detector.threshold = 4")).
     withFallback(MultiNodeClusterSpec.clusterConfig))
 }
 
@@ -25,7 +24,7 @@ class GossipingAccrualFailureDetectorMultiJvmNode2 extends GossipingAccrualFailu
 class GossipingAccrualFailureDetectorMultiJvmNode3 extends GossipingAccrualFailureDetectorSpec
 
 abstract class GossipingAccrualFailureDetectorSpec extends MultiNodeSpec(GossipingAccrualFailureDetectorMultiJvmSpec)
-  with MultiNodeClusterSpec with ImplicitSender with BeforeAndAfter {
+  with MultiNodeClusterSpec {
   import GossipingAccrualFailureDetectorMultiJvmSpec._
 
   override def initialParticipants = 3
@@ -34,10 +33,6 @@ abstract class GossipingAccrualFailureDetectorSpec extends MultiNodeSpec(Gossipi
   lazy val secondAddress = node(second).address
   lazy val thirdAddress = node(third).address
 
-  after {
-    testConductor.enter("after")
-  }
-
   "A Gossip-driven Failure Detector" must {
 
     "receive gossip heartbeats so that all member nodes in the cluster are marked 'available'" taggedAs LongRunningTest in {
@@ -53,12 +48,13 @@ abstract class GossipingAccrualFailureDetectorSpec extends MultiNodeSpec(Gossipi
       cluster.failureDetector.isAvailable(firstAddress) must be(true)
       cluster.failureDetector.isAvailable(secondAddress) must be(true)
       cluster.failureDetector.isAvailable(thirdAddress) must be(true)
+
+      testConductor.enter("after-1")
     }
 
     "mark node as 'unavailable' if a node in the cluster is shut down (and its heartbeats stops)" taggedAs LongRunningTest in {
       runOn(first) {
         testConductor.shutdown(third, 0)
-        testConductor.removeNode(third)
       }
 
       runOn(first, second) {
@@ -68,7 +64,8 @@ abstract class GossipingAccrualFailureDetectorSpec extends MultiNodeSpec(Gossipi
         cluster.failureDetector.isAvailable(firstAddress) must be(true)
         cluster.failureDetector.isAvailable(secondAddress) must be(true)
       }
+
+      testConductor.enter("after-2")
     }
   }
-
 }
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/JoinTwoClustersSpec.scala b/akka-cluster/src/multi-jvm/scala/akka/cluster/JoinTwoClustersSpec.scala
index 7b7263bbe0..e01839684a 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/JoinTwoClustersSpec.scala
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/JoinTwoClustersSpec.scala
@@ -78,7 +78,6 @@ abstract class JoinTwoClustersSpec
       assertLeader(c1, c2)
 
       testConductor.enter("four-members")
-
     }
 
     "be able to 'elect' a single leader after joining (C -> A + B)" taggedAs LongRunningTest in {
@@ -94,5 +93,4 @@ abstract class JoinTwoClustersSpec
       testConductor.enter("six-members")
     }
   }
-
 }
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/LeaderDowningNodeThatIsUnreachableSpec.scala b/akka-cluster/src/multi-jvm/scala/akka/cluster/LeaderDowningNodeThatIsUnreachableSpec.scala
index 7b2536d9d2..e8b956e87b 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/LeaderDowningNodeThatIsUnreachableSpec.scala
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/LeaderDowningNodeThatIsUnreachableSpec.scala
@@ -4,7 +4,6 @@
 package akka.cluster
 
 import com.typesafe.config.ConfigFactory
-import org.scalatest.BeforeAndAfter
 import akka.remote.testkit.MultiNodeConfig
 import akka.remote.testkit.MultiNodeSpec
 import akka.testkit._
@@ -52,7 +51,6 @@ class LeaderDowningNodeThatIsUnreachableSpec
 
         // kill 'fourth' node
         testConductor.shutdown(fourth, 0)
-        testConductor.removeNode(fourth)
         testConductor.enter("down-fourth-node")
 
         // --- HERE THE LEADER SHOULD DETECT FAILURE AND AUTO-DOWN THE UNREACHABLE NODE ---
@@ -92,7 +90,6 @@ class LeaderDowningNodeThatIsUnreachableSpec
 
         // kill 'second' node
         testConductor.shutdown(second, 0)
-        testConductor.removeNode(second)
         testConductor.enter("down-second-node")
 
         // --- HERE THE LEADER SHOULD DETECT FAILURE AND AUTO-DOWN THE UNREACHABLE NODE ---
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/LeaderElectionSpec.scala b/akka-cluster/src/multi-jvm/scala/akka/cluster/LeaderElectionSpec.scala
index bf60b6b4ac..5a155fc195 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/LeaderElectionSpec.scala
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/LeaderElectionSpec.scala
@@ -17,7 +17,6 @@ object LeaderElectionMultiJvmSpec extends MultiNodeConfig {
   val fourth = role("fourth")
 
   commonConfig(debugConfig(on = false).withFallback(MultiNodeClusterSpec.clusterConfig))
-
 }
 
 class LeaderElectionMultiJvmNode1 extends LeaderElectionSpec
@@ -69,7 +68,6 @@ abstract class LeaderElectionSpec
         case `controller` ⇒
           testConductor.enter("before-shutdown")
           testConductor.shutdown(leader, 0)
-          testConductor.removeNode(leader)
           testConductor.enter("after-shutdown", "after-down", "completed")
 
         case `leader` ⇒
@@ -95,7 +93,6 @@ abstract class LeaderElectionSpec
           testConductor.enter("completed")
 
       }
-
     }
 
     "be able to 're-elect' a single leader after leader has left" taggedAs LongRunningTest in {
@@ -106,5 +103,4 @@ abstract class LeaderElectionSpec
       shutdownLeaderAndVerifyNewLeader(alreadyShutdown = 1)
     }
   }
-
 }
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/MembershipChangeListenerSpec.scala b/akka-cluster/src/multi-jvm/scala/akka/cluster/MembershipChangeListenerSpec.scala
new file mode 100644
index 0000000000..352f9de1a4
--- /dev/null
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/MembershipChangeListenerSpec.scala
@@ -0,0 +1,78 @@
+/**
+ *  Copyright (C) 2009-2012 Typesafe Inc. <http://www.typesafe.com>
+ */
+package akka.cluster
+
+import scala.collection.immutable.SortedSet
+import com.typesafe.config.ConfigFactory
+import akka.remote.testkit.MultiNodeConfig
+import akka.remote.testkit.MultiNodeSpec
+import akka.testkit._
+
+object MembershipChangeListenerMultiJvmSpec extends MultiNodeConfig {
+  val first = role("first")
+  val second = role("second")
+  val third = role("third")
+
+  commonConfig(debugConfig(on = false).withFallback(MultiNodeClusterSpec.clusterConfig))
+}
+
+class MembershipChangeListenerMultiJvmNode1 extends MembershipChangeListenerSpec
+class MembershipChangeListenerMultiJvmNode2 extends MembershipChangeListenerSpec
+class MembershipChangeListenerMultiJvmNode3 extends MembershipChangeListenerSpec
+
+abstract class MembershipChangeListenerSpec extends MultiNodeSpec(MembershipChangeListenerMultiJvmSpec)
+  with MultiNodeClusterSpec {
+  import MembershipChangeListenerMultiJvmSpec._
+
+  override def initialParticipants = 3
+
+  lazy val firstAddress = node(first).address
+  lazy val secondAddress = node(second).address
+
+  "A set of connected cluster systems" must {
+
+    "(when two systems) after cluster convergence updates the membership table then all MembershipChangeListeners should be triggered" taggedAs LongRunningTest in {
+
+      // make sure that the node-to-join is started before other join
+      runOn(first) {
+        cluster.self
+      }
+      testConductor.enter("first-started")
+
+      runOn(first, second) {
+        cluster.join(firstAddress)
+        val latch = TestLatch()
+        cluster.registerListener(new MembershipChangeListener {
+          def notify(members: SortedSet[Member]) {
+            if (members.size == 2 && members.forall(_.status == MemberStatus.Up))
+              latch.countDown()
+          }
+        })
+        latch.await
+        cluster.convergence.isDefined must be(true)
+      }
+
+      testConductor.enter("after-1")
+    }
+
+    "(when three systems) after cluster convergence updates the membership table then all MembershipChangeListeners should be triggered" taggedAs LongRunningTest in {
+
+      runOn(third) {
+        cluster.join(firstAddress)
+      }
+
+      val latch = TestLatch()
+      cluster.registerListener(new MembershipChangeListener {
+        def notify(members: SortedSet[Member]) {
+          if (members.size == 3 && members.forall(_.status == MemberStatus.Up))
+            latch.countDown()
+        }
+      })
+      latch.await
+      cluster.convergence.isDefined must be(true)
+
+      testConductor.enter("after-2")
+    }
+  }
+}
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/MultiNodeClusterSpec.scala b/akka-cluster/src/multi-jvm/scala/akka/cluster/MultiNodeClusterSpec.scala
index dd57b4b13f..bf431f74f6 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/MultiNodeClusterSpec.scala
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/MultiNodeClusterSpec.scala
@@ -84,6 +84,17 @@ trait MultiNodeClusterSpec { self: MultiNodeSpec ⇒
     }
   }
 
+  /**
+   * Wait until the specified nodes have seen the same gossip overview.
+   */
+  def awaitSeenSameState(addresses: Seq[Address]): Unit = {
+    awaitCond {
+      val seen = cluster.latestGossip.overview.seen
+      val seenVectorClocks = addresses.flatMap(seen.get(_))
+      seenVectorClocks.size == addresses.size && seenVectorClocks.toSet.size == 1
+    }
+  }
+
   def roleOfLeader(nodesInCluster: Seq[RoleName]): RoleName = {
     nodesInCluster.length must not be (0)
     nodesInCluster.sorted.head
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/NodeLeavingAndExitingAndBeingRemovedSpec.scala b/akka-cluster/src/multi-jvm/scala/akka/cluster/NodeLeavingAndExitingAndBeingRemovedSpec.scala
index da500323aa..ebab4f6ba3 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/NodeLeavingAndExitingAndBeingRemovedSpec.scala
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/NodeLeavingAndExitingAndBeingRemovedSpec.scala
@@ -4,7 +4,6 @@
 package akka.cluster
 
 import scala.collection.immutable.SortedSet
-import org.scalatest.BeforeAndAfter
 import com.typesafe.config.ConfigFactory
 import akka.remote.testkit.MultiNodeConfig
 import akka.remote.testkit.MultiNodeSpec
@@ -23,8 +22,10 @@ class NodeLeavingAndExitingAndBeingRemovedMultiJvmNode1 extends NodeLeavingAndEx
 class NodeLeavingAndExitingAndBeingRemovedMultiJvmNode2 extends NodeLeavingAndExitingAndBeingRemovedSpec
 class NodeLeavingAndExitingAndBeingRemovedMultiJvmNode3 extends NodeLeavingAndExitingAndBeingRemovedSpec
 
-abstract class NodeLeavingAndExitingAndBeingRemovedSpec extends MultiNodeSpec(NodeLeavingAndExitingAndBeingRemovedMultiJvmSpec)
-  with MultiNodeClusterSpec with ImplicitSender with BeforeAndAfter {
+abstract class NodeLeavingAndExitingAndBeingRemovedSpec
+  extends MultiNodeSpec(NodeLeavingAndExitingAndBeingRemovedMultiJvmSpec)
+  with MultiNodeClusterSpec {
+
   import NodeLeavingAndExitingAndBeingRemovedMultiJvmSpec._
 
   override def initialParticipants = 3
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/NodeLeavingAndExitingSpec.scala b/akka-cluster/src/multi-jvm/scala/akka/cluster/NodeLeavingAndExitingSpec.scala
index 189cb4c9c6..31630f934c 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/NodeLeavingAndExitingSpec.scala
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/NodeLeavingAndExitingSpec.scala
@@ -4,7 +4,6 @@
 package akka.cluster
 
 import scala.collection.immutable.SortedSet
-import org.scalatest.BeforeAndAfter
 import com.typesafe.config.ConfigFactory
 import akka.remote.testkit.MultiNodeConfig
 import akka.remote.testkit.MultiNodeSpec
@@ -18,13 +17,13 @@ object NodeLeavingAndExitingMultiJvmSpec extends MultiNodeConfig {
 
   commonConfig(
     debugConfig(on = false)
-    .withFallback(ConfigFactory.parseString("""
+      .withFallback(ConfigFactory.parseString("""
         akka.cluster {
           leader-actions-interval           = 5 s  # increase the leader action task frequency to make sure we get a chance to test the LEAVING state
-          unreachable-nodes-reaper-interval = 30 s # turn "off" reaping to unreachable node set
+          unreachable-nodes-reaper-interval = 30 s
         }
       """)
-    .withFallback(MultiNodeClusterSpec.clusterConfig)))
+        .withFallback(MultiNodeClusterSpec.clusterConfig)))
 }
 
 class NodeLeavingAndExitingMultiJvmNode1 extends NodeLeavingAndExitingSpec
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/NodeLeavingSpec.scala b/akka-cluster/src/multi-jvm/scala/akka/cluster/NodeLeavingSpec.scala
index ad445b4c42..17db90c880 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/NodeLeavingSpec.scala
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/NodeLeavingSpec.scala
@@ -4,7 +4,6 @@
 package akka.cluster
 
 import scala.collection.immutable.SortedSet
-import org.scalatest.BeforeAndAfter
 import com.typesafe.config.ConfigFactory
 import akka.remote.testkit.MultiNodeConfig
 import akka.remote.testkit.MultiNodeSpec
@@ -17,11 +16,10 @@ object NodeLeavingMultiJvmSpec extends MultiNodeConfig {
 
   commonConfig(
     debugConfig(on = false)
-    .withFallback(ConfigFactory.parseString("""
-        akka.cluster.leader-actions-interval           = 5 s
-        akka.cluster.unreachable-nodes-reaper-interval = 30 s # turn "off" reaping to unreachable node set
+      .withFallback(ConfigFactory.parseString("""
+        akka.cluster.unreachable-nodes-reaper-frequency = 30 s
       """))
-    .withFallback(MultiNodeClusterSpec.clusterConfig))
+      .withFallback(MultiNodeClusterSpec.clusterConfig))
 }
 
 class NodeLeavingMultiJvmNode1 extends NodeLeavingSpec
@@ -29,7 +27,7 @@ class NodeLeavingMultiJvmNode2 extends NodeLeavingSpec
 class NodeLeavingMultiJvmNode3 extends NodeLeavingSpec
 
 abstract class NodeLeavingSpec extends MultiNodeSpec(NodeLeavingMultiJvmSpec)
-  with MultiNodeClusterSpec with ImplicitSender with BeforeAndAfter {
+  with MultiNodeClusterSpec {
   import NodeLeavingMultiJvmSpec._
 
   override def initialParticipants = 3
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/NodeMembershipSpec.scala b/akka-cluster/src/multi-jvm/scala/akka/cluster/NodeMembershipSpec.scala
index 369dcf56ad..edd3e44121 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/NodeMembershipSpec.scala
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/NodeMembershipSpec.scala
@@ -4,7 +4,6 @@
 package akka.cluster
 
 import com.typesafe.config.ConfigFactory
-import org.scalatest.BeforeAndAfter
 import akka.remote.testkit.MultiNodeConfig
 import akka.remote.testkit.MultiNodeSpec
 import akka.testkit._
@@ -15,7 +14,6 @@ object NodeMembershipMultiJvmSpec extends MultiNodeConfig {
   val third = role("third")
 
   commonConfig(debugConfig(on = false).withFallback(MultiNodeClusterSpec.clusterConfig))
-
 }
 
 class NodeMembershipMultiJvmNode1 extends NodeMembershipSpec
@@ -24,17 +22,12 @@ class NodeMembershipMultiJvmNode3 extends NodeMembershipSpec
 
 abstract class NodeMembershipSpec
   extends MultiNodeSpec(NodeMembershipMultiJvmSpec)
-  with MultiNodeClusterSpec
-  with ImplicitSender with BeforeAndAfter {
+  with MultiNodeClusterSpec {
 
   import NodeMembershipMultiJvmSpec._
 
   override def initialParticipants = 3
 
-  after {
-    testConductor.enter("after")
-  }
-
   lazy val firstAddress = node(first).address
   lazy val secondAddress = node(second).address
   lazy val thirdAddress = node(third).address
@@ -59,6 +52,7 @@ abstract class NodeMembershipSpec
         awaitCond(cluster.convergence.isDefined)
       }
 
+      testConductor.enter("after-1")
     }
 
     "(when three nodes) start gossiping to each other so that all nodes gets the same gossip info" taggedAs LongRunningTest in {
@@ -74,7 +68,7 @@ abstract class NodeMembershipSpec
       }
       awaitCond(cluster.convergence.isDefined)
 
+      testConductor.enter("after-2")
     }
   }
-
 }
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/NodeShutdownSpec.scala b/akka-cluster/src/multi-jvm/scala/akka/cluster/NodeShutdownSpec.scala
index a9a5ee3233..c0ac1ee22b 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/NodeShutdownSpec.scala
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/NodeShutdownSpec.scala
@@ -4,7 +4,6 @@
 package akka.cluster
 
 import com.typesafe.config.ConfigFactory
-import org.scalatest.BeforeAndAfter
 import akka.remote.testkit.MultiNodeConfig
 import akka.remote.testkit.MultiNodeSpec
 import akka.testkit._
@@ -28,15 +27,11 @@ object NodeShutdownMultiJvmSpec extends MultiNodeConfig {
 class NodeShutdownMultiJvmNode1 extends NodeShutdownSpec
 class NodeShutdownMultiJvmNode2 extends NodeShutdownSpec
 
-abstract class NodeShutdownSpec extends MultiNodeSpec(NodeShutdownMultiJvmSpec) with MultiNodeClusterSpec with ImplicitSender with BeforeAndAfter {
+abstract class NodeShutdownSpec extends MultiNodeSpec(NodeShutdownMultiJvmSpec) with MultiNodeClusterSpec {
   import NodeShutdownMultiJvmSpec._
 
   override def initialParticipants = 2
 
-  after {
-    testConductor.enter("after")
-  }
-
   "A cluster of 2 nodes" must {
 
     "not be singleton cluster when joined" taggedAs LongRunningTest in {
@@ -52,17 +47,20 @@ abstract class NodeShutdownSpec extends MultiNodeSpec(NodeShutdownMultiJvmSpec)
       awaitUpConvergence(numberOfMembers = 2)
       cluster.isSingletonCluster must be(false)
       assertLeader(first, second)
+
+      testConductor.enter("after-1")
     }
 
     "become singleton cluster when one node is shutdown" taggedAs LongRunningTest in {
       runOn(first) {
         val secondAddress = node(second).address
         testConductor.shutdown(second, 0)
-        testConductor.removeNode(second)
         awaitUpConvergence(numberOfMembers = 1, canNotBePartOfMemberRing = Seq(secondAddress), 30.seconds)
         cluster.isSingletonCluster must be(true)
         assertLeader(first)
       }
+
+      testConductor.enter("after-2")
     }
   }
 }
diff --git a/akka-docs/java/remoting.rst b/akka-docs/java/remoting.rst
index ae2ac9c246..910ec5fbb2 100644
--- a/akka-docs/java/remoting.rst
+++ b/akka-docs/java/remoting.rst
@@ -92,6 +92,14 @@ As you can see from the example above the following pattern is used to find an `
 
     akka://<actorsystemname>@<hostname>:<port>/<actor path>
 
+.. note::
+
+  In order to ensure serializability of ``Props`` when passing constructor
+  arguments to the actor being created, do not make the factory a non-static
+  inner class: this will inherently capture a reference to its enclosing
+  object, which in most cases is not serializable. It is best to make a static
+  inner class which implements :class:`UntypedActorFactory`.
+
 Programmatic Remote Deployment
 ------------------------------
 
diff --git a/akka-docs/scala/code/docs/testkit/TestkitDocSpec.scala b/akka-docs/scala/code/docs/testkit/TestkitDocSpec.scala
index ddb3eeaf1d..564b7929ce 100644
--- a/akka-docs/scala/code/docs/testkit/TestkitDocSpec.scala
+++ b/akka-docs/scala/code/docs/testkit/TestkitDocSpec.scala
@@ -14,6 +14,8 @@ import akka.dispatch.Futures
 import akka.testkit.AkkaSpec
 import akka.testkit.DefaultTimeout
 import akka.testkit.ImplicitSender
+import akka.util.NonFatal
+
 object TestkitDocSpec {
   case object Say42
   case object Unknown
@@ -208,7 +210,7 @@ class TestkitDocSpec extends AkkaSpec with DefaultTimeout with ImplicitSender {
     val probe = TestProbe()
     val future = probe.ref ? "hello"
     probe.expectMsg(0 millis, "hello") // TestActor runs on CallingThreadDispatcher
-    probe.sender ! "world"
+    probe.reply("world")
     assert(future.isCompleted && future.value == Some(Right("world")))
     //#test-probe-reply
   }
@@ -252,4 +254,22 @@ class TestkitDocSpec extends AkkaSpec with DefaultTimeout with ImplicitSender {
     //#event-filter
   }
 
+  "demonstrate TestKitBase" in {
+    //#test-kit-base
+    import akka.testkit.TestKitBase
+
+    class MyTest extends TestKitBase {
+      implicit lazy val system = ActorSystem()
+
+      //#put-your-test-code-here
+      val probe = TestProbe()
+      probe.send(testActor, "hello")
+      try expectMsg("hello") catch { case NonFatal(e) ⇒ system.shutdown(); throw e }
+      //#put-your-test-code-here
+
+      system.shutdown()
+    }
+    //#test-kit-base
+  }
+
 }
diff --git a/akka-docs/scala/remoting.rst b/akka-docs/scala/remoting.rst
index 0f55ccdff4..0863d80b55 100644
--- a/akka-docs/scala/remoting.rst
+++ b/akka-docs/scala/remoting.rst
@@ -105,6 +105,14 @@ Once you have configured the properties above you would do the following in code
 ``SampleActor`` has to be available to the runtimes using it, i.e. the classloader of the
 actor systems has to have a JAR containing the class.
 
+.. note::
+
+  In order to ensure serializability of ``Props`` when passing constructor
+  arguments to the actor being created, do not make the factory an inner class:
+  this will inherently capture a reference to its enclosing object, which in
+  most cases is not serializable. It is best to create a factory method in the
+  companion object of the actor’s class.
+
 Programmatic Remote Deployment
 ------------------------------
 
diff --git a/akka-docs/scala/testing.rst b/akka-docs/scala/testing.rst
index a98ee14917..d19a1ab753 100644
--- a/akka-docs/scala/testing.rst
+++ b/akka-docs/scala/testing.rst
@@ -671,6 +671,25 @@ This section contains a collection of known gotchas with some other frameworks,
 which is by no means exhaustive and does not imply endorsement or special
 support.
 
+When you need it to be a trait
+------------------------------
+
+If for some reason it is a problem to inherit from :class:`TestKit` due to it
+being a concrete class instead of a trait, there’s :class:`TestKitBase`:
+
+.. includecode:: code/docs/testkit/TestkitDocSpec.scala
+   :include: test-kit-base
+   :exclude: put-your-test-code-here
+
+The ``implicit lazy val system`` must be declared exactly like that (you can of
+course pass arguments to the actor system factory as needed) because trait
+:class:`TestKitBase` needs the system during its construction.
+
+.. warning::
+
+  Use of the trait is discouraged because of potential issues with binary
+  backwards compatibility in the future, use at own risk.
+
 Specs2
 ------
 
diff --git a/akka-remote-tests/src/main/scala/akka/remote/testconductor/Conductor.scala b/akka-remote-tests/src/main/scala/akka/remote/testconductor/Conductor.scala
index 8fa8eeff21..17a2bfcd5f 100644
--- a/akka-remote-tests/src/main/scala/akka/remote/testconductor/Conductor.scala
+++ b/akka-remote-tests/src/main/scala/akka/remote/testconductor/Conductor.scala
@@ -168,7 +168,8 @@ trait Conductor { this: TestConductorExt ⇒
 
   /**
    * Tell the remote node to shut itself down using System.exit with the given
-   * exitValue.
+   * exitValue. The node will also be removed, so that the remaining nodes may still
+   * pass subsequent barriers.
    *
    * @param node is the symbolic name of the node which is to be affected
    * @param exitValue is the return code which shall be given to System.exit
@@ -441,10 +442,10 @@ private[akka] class Controller(private var initialParticipants: Int, controllerP
           if (exitValueOrKill < 0) {
             // TODO: kill via SBT
           } else {
+            barrier ! BarrierCoordinator.RemoveClient(node)
             nodes(node).fsm forward ToClient(TerminateMsg(exitValueOrKill))
           }
         case Remove(node) ⇒
-          nodes -= node
           barrier ! BarrierCoordinator.RemoveClient(node)
       }
     case GetNodes    ⇒ sender ! nodes.keys
@@ -540,8 +541,8 @@ private[akka] class BarrierCoordinator extends Actor with LoggingFSM[BarrierCoor
 
   when(Waiting) {
     case Event(EnterBarrier(name), d @ Data(clients, barrier, arrived)) ⇒
-      if (name != barrier || clients.find(_.fsm == sender).isEmpty) throw WrongBarrier(name, sender, d)
-      val together = sender :: arrived
+      if (name != barrier) throw WrongBarrier(name, sender, d)
+      val together = if (clients.exists(_.fsm == sender)) sender :: arrived else arrived
       handleBarrier(d.copy(arrived = together))
     case Event(RemoveClient(name), d @ Data(clients, barrier, arrived)) ⇒
       clients find (_.name == name) match {
diff --git a/akka-remote-tests/src/test/scala/akka/remote/testkit/LogRoleReplace.scala b/akka-remote-tests/src/test/scala/akka/remote/testkit/LogRoleReplace.scala
new file mode 100644
index 0000000000..3b3527240e
--- /dev/null
+++ b/akka-remote-tests/src/test/scala/akka/remote/testkit/LogRoleReplace.scala
@@ -0,0 +1,148 @@
+package akka.remote.testkit
+
+import java.awt.Toolkit
+import java.awt.datatransfer.Clipboard
+import java.awt.datatransfer.ClipboardOwner
+import java.awt.datatransfer.DataFlavor
+import java.awt.datatransfer.StringSelection
+import java.awt.datatransfer.Transferable
+import java.io.BufferedReader
+import java.io.FileReader
+import java.io.FileWriter
+import java.io.InputStreamReader
+import java.io.OutputStreamWriter
+import java.io.PrintWriter
+import java.io.StringReader
+import java.io.StringWriter
+import scala.annotation.tailrec
+
+/**
+ * Utility to make log files from multi-node tests easier to analyze.
+ * Replaces jvm names and host:port with corresponding logical role name.
+ */
+object LogRoleReplace extends ClipboardOwner {
+
+  /**
+   * Main program. Use with 0, 1 or 2 arguments.
+   *
+   * When using 0 arguments it reads from standard input
+   * (System.in) and writes to standard output (System.out).
+   *
+   * With 1 argument it reads from the file specified in the first argument
+   * and writes to standard output.
+   *
+   * With 2 arguments it reads the file specified in the first argument
+   * and writes to the file specified in the second argument.
+   *
+   * You can also replace the contents of the clipboard instead of using files
+   * by supplying `clipboard` as argument
+   */
+  def main(args: Array[String]): Unit = {
+    val replacer = new LogRoleReplace
+
+    if (args.length == 0) {
+      replacer.process(
+        new BufferedReader(new InputStreamReader(System.in)),
+        new PrintWriter(new OutputStreamWriter(System.out)))
+
+    } else if (args(0) == "clipboard") {
+      val clipboard = Toolkit.getDefaultToolkit.getSystemClipboard
+      val contents = clipboard.getContents(null)
+      if (contents != null && contents.isDataFlavorSupported(DataFlavor.stringFlavor)) {
+        val text = contents.getTransferData(DataFlavor.stringFlavor).asInstanceOf[String]
+        val result = new StringWriter
+        replacer.process(
+          new BufferedReader(new StringReader(text)),
+          new PrintWriter(result))
+        clipboard.setContents(new StringSelection(result.toString), this)
+        println("Replaced clipboard contents")
+      }
+
+    } else if (args.length == 1) {
+      val inputFile = new BufferedReader(new FileReader(args(0)))
+      try {
+        replacer.process(
+          inputFile,
+          new PrintWriter(new OutputStreamWriter(System.out)))
+      } finally {
+        inputFile.close()
+      }
+
+    } else if (args.length == 2) {
+      val outputFile = new PrintWriter(new FileWriter(args(1)))
+      val inputFile = new BufferedReader(new FileReader(args(0)))
+      try {
+        replacer.process(inputFile, outputFile)
+      } finally {
+        outputFile.close()
+        inputFile.close()
+      }
+    }
+  }
+
+  /**
+   * Empty implementation of the ClipboardOwner interface
+   */
+  def lostOwnership(clipboard: Clipboard, contents: Transferable): Unit = ()
+}
+
+class LogRoleReplace {
+
+  private val RoleStarted = """\[([\w\-]+)\].*Role \[([\w]+)\] started""".r
+  private val RemoteServerStarted = """\[([\w\-]+)\].*RemoteServerStarted@akka://.*@([\w\-\.]+):([0-9]+)""".r
+
+  private var replacements: Map[String, String] = Map.empty
+  private var jvmToAddress: Map[String, String] = Map.empty
+
+  def process(in: BufferedReader, out: PrintWriter): Unit = {
+
+    @tailrec
+    def processLines(line: String): Unit = if (line ne null) {
+      out.println(processLine(line))
+      processLines(in.readLine)
+    }
+
+    processLines(in.readLine())
+  }
+
+  def processLine(line: String): String = {
+    if (updateReplacements(line))
+      replaceLine(line)
+    else
+      line
+  }
+
+  private def updateReplacements(line: String): Boolean = {
+    if (line.startsWith("[info] * ")) {
+      // reset when new test begins
+      replacements = Map.empty
+      jvmToAddress = Map.empty
+    }
+
+    line match {
+      case RemoteServerStarted(jvm, host, port) ⇒
+        jvmToAddress += (jvm -> (host + ":" + port))
+        false
+
+      case RoleStarted(jvm, role) ⇒
+        jvmToAddress.get(jvm) match {
+          case Some(address) ⇒
+            replacements += (jvm -> role)
+            replacements += (address -> role)
+            false
+          case None ⇒ false
+        }
+
+      case _ ⇒ true
+    }
+  }
+
+  private def replaceLine(line: String): String = {
+    var result = line
+    for ((from, to) ← replacements) {
+      result = result.replaceAll(from, to)
+    }
+    result
+  }
+
+}
\ No newline at end of file
diff --git a/akka-remote-tests/src/test/scala/akka/remote/testkit/MultiNodeSpec.scala b/akka-remote-tests/src/test/scala/akka/remote/testkit/MultiNodeSpec.scala
index 35a9cc14e7..01a08da718 100644
--- a/akka-remote-tests/src/test/scala/akka/remote/testkit/MultiNodeSpec.scala
+++ b/akka-remote-tests/src/test/scala/akka/remote/testkit/MultiNodeSpec.scala
@@ -3,23 +3,16 @@
  */
 package akka.remote.testkit
 
-import akka.testkit.AkkaSpec
-import akka.actor.{ ActorSystem, ExtendedActorSystem }
-import akka.remote.testconductor.TestConductor
-import java.net.InetAddress
 import java.net.InetSocketAddress
-import akka.remote.testconductor.TestConductorExt
-import com.typesafe.config.Config
-import com.typesafe.config.ConfigFactory
-import akka.dispatch.Await.Awaitable
+
+import com.typesafe.config.{ ConfigObject, ConfigFactory, Config }
+
+import akka.actor.{ RootActorPath, Deploy, ActorPath, ActorSystem, ExtendedActorSystem }
 import akka.dispatch.Await
-import akka.util.Duration
-import akka.util.NonFatal
-import akka.actor.ActorPath
-import akka.actor.RootActorPath
-import akka.remote.testconductor.RoleName
-import akka.actor.Deploy
-import com.typesafe.config.ConfigObject
+import akka.dispatch.Await.Awaitable
+import akka.remote.testconductor.{ TestConductorExt, TestConductor, RoleName }
+import akka.testkit.AkkaSpec
+import akka.util.{ NonFatal, Duration }
 
 /**
  * Configure the role names and participants of the test, including configuration settings.
@@ -144,7 +137,7 @@ abstract class MultiNodeSpec(val myself: RoleName, _system: ActorSystem, roles:
   import MultiNodeSpec._
 
   def this(config: MultiNodeConfig) =
-    this(config.myself, ActorSystem(AkkaSpec.getCallerName, config.config), config.roles, config.deployments)
+    this(config.myself, ActorSystem(AkkaSpec.getCallerName(classOf[MultiNodeSpec]), config.config), config.roles, config.deployments)
 
   /*
    * Test Class Interface
@@ -249,4 +242,7 @@ abstract class MultiNodeSpec(val myself: RoleName, _system: ActorSystem, roles:
     }
   }
 
-}
\ No newline at end of file
+  // useful to see which jvm is running which role
+  log.info("Role [{}] started", myself.name)
+
+}
diff --git a/akka-testkit/src/main/scala/akka/testkit/TestActorRef.scala b/akka-testkit/src/main/scala/akka/testkit/TestActorRef.scala
index 0a5d6163e8..279c728e80 100644
--- a/akka-testkit/src/main/scala/akka/testkit/TestActorRef.scala
+++ b/akka-testkit/src/main/scala/akka/testkit/TestActorRef.scala
@@ -56,7 +56,17 @@ class TestActorRef[T <: Actor](
    * thrown will be available to you, while still being able to use
    * become/unbecome.
    */
-  def receive(o: Any): Unit = underlying.receiveMessage(o)
+  def receive(o: Any): Unit = receive(o, underlying.system.deadLetters)
+
+  /**
+   * Directly inject messages into actor receive behavior. Any exceptions
+   * thrown will be available to you, while still being able to use
+   * become/unbecome.
+   */
+  def receive(o: Any, sender: ActorRef): Unit = try {
+    underlying.currentMessage = Envelope(o, if (sender eq null) underlying.system.deadLetters else sender)(underlying.system)
+    underlying.receiveMessage(o)
+  } finally underlying.currentMessage = null
 
   /**
    * Retrieve reference to the underlying actor, where the static type matches the factory used inside the
diff --git a/akka-testkit/src/main/scala/akka/testkit/TestKit.scala b/akka-testkit/src/main/scala/akka/testkit/TestKit.scala
index 156a9d8612..c0fb6e5267 100644
--- a/akka-testkit/src/main/scala/akka/testkit/TestKit.scala
+++ b/akka-testkit/src/main/scala/akka/testkit/TestKit.scala
@@ -62,50 +62,28 @@ class TestActor(queue: BlockingDeque[TestActor.Message]) extends Actor {
 }
 
 /**
- * Test kit for testing actors. Inheriting from this trait enables reception of
- * replies from actors, which are queued by an internal actor and can be
- * examined using the `expectMsg...` methods. Assertions and bounds concerning
- * timing are available in the form of `within` blocks.
+ * Implementation trait behind the [[akka.testkit.TestKit]] class: you may use
+ * this if inheriting from a concrete class is not possible.
  *
- * <pre>
- * class Test extends TestKit(ActorSystem()) {
- *     try {
+ * <b>Use of the trait is discouraged because of potential issues with binary
+ * backwards compatibility in the future, use at own risk.</b>
  *
- *       val test = system.actorOf(Props[SomeActor]
+ * This trait requires the concrete class mixing it in to provide an
+ * [[akka.actor.ActorSystem]] which is available before this traits’s
+ * constructor is run. The recommended way is this:
  *
- *       within (1 second) {
- *         test ! SomeWork
- *         expectMsg(Result1) // bounded to 1 second
- *         expectMsg(Result2) // bounded to the remainder of the 1 second
- *       }
- *
- *     } finally {
- *       system.shutdown()
- *     }
+ * {{{
+ * class MyTest extends TestKitBase {
+ *   implicit lazy val system = ActorSystem() // may add arguments here
+ *   ...
  * }
- * </pre>
- *
- * Beware of two points:
- *
- *  - the ActorSystem passed into the constructor needs to be shutdown,
- *    otherwise thread pools and memory will be leaked
- *  - this trait is not thread-safe (only one actor with one queue, one stack
- *    of `within` blocks); it is expected that the code is executed from a
- *    constructor as shown above, which makes this a non-issue, otherwise take
- *    care not to run tests within a single test class instance in parallel.
- *
- * It should be noted that for CI servers and the like all maximum Durations
- * are scaled using their Duration.dilated method, which uses the
- * TestKitExtension.Settings.TestTimeFactor settable via akka.conf entry "akka.test.timefactor".
- *
- * @author Roland Kuhn
- * @since 1.1
+ * }}}
  */
-class TestKit(_system: ActorSystem) {
+trait TestKitBase {
 
   import TestActor.{ Message, RealMessage, NullMessage }
 
-  implicit val system = _system
+  implicit val system: ActorSystem
   val testKitSettings = TestKitExtension(system)
 
   private val queue = new LinkedBlockingDeque[Message]()
@@ -579,6 +557,48 @@ class TestKit(_system: ActorSystem) {
   private def format(u: TimeUnit, d: Duration) = "%.3f %s".format(d.toUnit(u), u.toString.toLowerCase)
 }
 
+/**
+ * Test kit for testing actors. Inheriting from this trait enables reception of
+ * replies from actors, which are queued by an internal actor and can be
+ * examined using the `expectMsg...` methods. Assertions and bounds concerning
+ * timing are available in the form of `within` blocks.
+ *
+ * <pre>
+ * class Test extends TestKit(ActorSystem()) {
+ *     try {
+ *
+ *       val test = system.actorOf(Props[SomeActor]
+ *
+ *       within (1 second) {
+ *         test ! SomeWork
+ *         expectMsg(Result1) // bounded to 1 second
+ *         expectMsg(Result2) // bounded to the remainder of the 1 second
+ *       }
+ *
+ *     } finally {
+ *       system.shutdown()
+ *     }
+ * }
+ * </pre>
+ *
+ * Beware of two points:
+ *
+ *  - the ActorSystem passed into the constructor needs to be shutdown,
+ *    otherwise thread pools and memory will be leaked
+ *  - this trait is not thread-safe (only one actor with one queue, one stack
+ *    of `within` blocks); it is expected that the code is executed from a
+ *    constructor as shown above, which makes this a non-issue, otherwise take
+ *    care not to run tests within a single test class instance in parallel.
+ *
+ * It should be noted that for CI servers and the like all maximum Durations
+ * are scaled using their Duration.dilated method, which uses the
+ * TestKitExtension.Settings.TestTimeFactor settable via akka.conf entry "akka.test.timefactor".
+ *
+ * @author Roland Kuhn
+ * @since 1.1
+ */
+class TestKit(_system: ActorSystem) extends { implicit val system = _system } with TestKitBase
+
 object TestKit {
   private[testkit] val testActorId = new AtomicInteger(0)
 
@@ -640,22 +660,23 @@ class TestProbe(_application: ActorSystem) extends TestKit(_application) {
    * Replies will be available for inspection with all of TestKit's assertion
    * methods.
    */
-  def send(actor: ActorRef, msg: AnyRef) = {
-    actor.!(msg)(testActor)
-  }
+  def send(actor: ActorRef, msg: Any): Unit = actor.!(msg)(testActor)
 
   /**
    * Forward this message as if in the TestActor's receive method with self.forward.
    */
-  def forward(actor: ActorRef, msg: AnyRef = lastMessage.msg) {
-    actor.!(msg)(lastMessage.sender)
-  }
+  def forward(actor: ActorRef, msg: Any = lastMessage.msg): Unit = actor.!(msg)(lastMessage.sender)
 
   /**
    * Get sender of last received message.
    */
   def sender = lastMessage.sender
 
+  /**
+   * Send message to the sender of the last dequeued message.
+   */
+  def reply(msg: Any): Unit = sender.!(msg)(ref)
+
 }
 
 object TestProbe {
diff --git a/akka-testkit/src/test/scala/akka/testkit/AkkaSpec.scala b/akka-testkit/src/test/scala/akka/testkit/AkkaSpec.scala
index f24ea49b8c..c7000f2cf7 100644
--- a/akka-testkit/src/test/scala/akka/testkit/AkkaSpec.scala
+++ b/akka-testkit/src/test/scala/akka/testkit/AkkaSpec.scala
@@ -46,9 +46,13 @@ object AkkaSpec {
     ConfigFactory.parseMap(map.asJava)
   }
 
-  def getCallerName: String = {
+  def getCallerName(clazz: Class[_]): String = {
     val s = Thread.currentThread.getStackTrace map (_.getClassName) drop 1 dropWhile (_ matches ".*AkkaSpec.?$")
-    s.head.replaceFirst(""".*\.""", "").replaceAll("[^a-zA-Z_0-9]", "_")
+    val reduced = s.lastIndexWhere(_ == clazz.getName) match {
+      case -1 ⇒ s
+      case z  ⇒ s drop (z + 1)
+    }
+    reduced.head.replaceFirst(""".*\.""", "").replaceAll("[^a-zA-Z_0-9]", "_")
   }
 
 }
@@ -56,13 +60,13 @@ object AkkaSpec {
 abstract class AkkaSpec(_system: ActorSystem)
   extends TestKit(_system) with WordSpec with MustMatchers with BeforeAndAfterAll {
 
-  def this(config: Config) = this(ActorSystem(AkkaSpec.getCallerName, config.withFallback(AkkaSpec.testConf)))
+  def this(config: Config) = this(ActorSystem(AkkaSpec.getCallerName(getClass), config.withFallback(AkkaSpec.testConf)))
 
   def this(s: String) = this(ConfigFactory.parseString(s))
 
   def this(configMap: Map[String, _]) = this(AkkaSpec.mapToConfig(configMap))
 
-  def this() = this(ActorSystem(AkkaSpec.getCallerName, AkkaSpec.testConf))
+  def this() = this(ActorSystem(AkkaSpec.getCallerName(getClass), AkkaSpec.testConf))
 
   val log: LoggingAdapter = Logging(system, this.getClass)
 
diff --git a/akka-testkit/src/test/scala/akka/testkit/TestActorRefSpec.scala b/akka-testkit/src/test/scala/akka/testkit/TestActorRefSpec.scala
index 7c977884fc..492c44408c 100644
--- a/akka-testkit/src/test/scala/akka/testkit/TestActorRefSpec.scala
+++ b/akka-testkit/src/test/scala/akka/testkit/TestActorRefSpec.scala
@@ -246,11 +246,18 @@ class TestActorRefSpec extends AkkaSpec("disp1.type=Dispatcher") with BeforeAndA
       a.underlying.dispatcher.getClass must be(classOf[Dispatcher])
     }
 
-    "proxy receive for the underlying actor" in {
+    "proxy receive for the underlying actor without sender" in {
       val ref = TestActorRef[WorkerActor]
       ref.receive("work")
       ref.isTerminated must be(true)
     }
 
+    "proxy receive for the underlying actor with sender" in {
+      val ref = TestActorRef[WorkerActor]
+      ref.receive("work", testActor)
+      ref.isTerminated must be(true)
+      expectMsg("workDone")
+    }
+
   }
 }
diff --git a/project/scripts/multi-node-log-replace b/project/scripts/multi-node-log-replace
new file mode 100755
index 0000000000..83f1b8a136
--- /dev/null
+++ b/project/scripts/multi-node-log-replace
@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+#
+# Utility to make log files from multi-node tests easier to analyze.
+# Replaces jvm names and host:port with corresponding logical role name.
+#
+
+
+# check for an sbt command
+type -P sbt &> /dev/null || fail "sbt command not found"
+
+sbt "project akka-remote-tests" "test:run-main akka.remote.testkit.LogRoleReplace $1 $2"
\ No newline at end of file
diff --git a/scripts/multi-node-log-replace.sh b/scripts/multi-node-log-replace.sh
new file mode 100755
index 0000000000..8e8af7112a
--- /dev/null
+++ b/scripts/multi-node-log-replace.sh
@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+#
+# Utility to make log files from multi-node tests easier to analyze.
+# Replaces jvm names and host:port with corresponding logical role name.
+#
+# Use with 0, 1 or 2 arguments.
+#
+# When using 0 arguments it reads from standard input
+# and writes to standard output.
+#
+# With 1 argument it reads from the file specified in the first argument
+# and writes to standard output.
+#
+# With 2 arguments it reads the file specified in the first argument
+# and writes to the file specified in the second argument.
+#
+# You can also replace the contents of the clipboard instead of using files
+# by supplying `clipboard` as argument
+#
+
+
+# check for an sbt command
+type -P sbt &> /dev/null || fail "sbt command not found"
+
+sbt "project akka-remote-tests" "test:run-main akka.remote.testkit.LogRoleReplace $1 $2"
\ No newline at end of file