diff --git a/akka-actor/src/main/scala/akka/actor/Actor.scala b/akka-actor/src/main/scala/akka/actor/Actor.scala
index a14f41f2f3..d9ee3ab41c 100644
--- a/akka-actor/src/main/scala/akka/actor/Actor.scala
+++ b/akka-actor/src/main/scala/akka/actor/Actor.scala
@@ -221,11 +221,12 @@ object EventHandler extends ListenerManagement {
 
   config.getList("akka.event-handlers") foreach { listenerName =>
     try {
-      val clazz = Thread.currentThread.getContextClassLoader.loadClass(listenerName).asInstanceOf[Class[_]]
-      addListener(Actor.actorOf(clazz.asInstanceOf[Class[_ <: Actor]]).start)
+      ReflectiveAccess.getClassFor[Actor](listenerName) map {
+        clazz => addListener(Actor.actorOf(clazz).start)
+      }
     } catch {
       case e: Exception =>
-        new ConfigurationException(
+        throw new ConfigurationException(
           "Event Handler specified in config can't be loaded [" + listenerName +
           "] due to [" + e.toString + "]")
     }
diff --git a/akka-actor/src/main/scala/akka/util/ReflectiveAccess.scala b/akka-actor/src/main/scala/akka/util/ReflectiveAccess.scala
index d64704589a..95364992ba 100644
--- a/akka-actor/src/main/scala/akka/util/ReflectiveAccess.scala
+++ b/akka-actor/src/main/scala/akka/util/ReflectiveAccess.scala
@@ -132,36 +132,45 @@ object ReflectiveAccess {
                         params: Array[Class[_]],
                         args: Array[AnyRef],
                         classloader: ClassLoader = loader): Option[T] = try {
-    assert(fqn ne null)
     assert(params ne null)
     assert(args ne null)
-    val clazz = classloader.loadClass(fqn)
-    val ctor = clazz.getDeclaredConstructor(params: _*)
-    ctor.setAccessible(true)
-    Some(ctor.newInstance(args: _*).asInstanceOf[T])
+    getClassFor(fqn) match {
+      case Some(clazz) =>
+        val ctor = clazz.getDeclaredConstructor(params: _*)
+        ctor.setAccessible(true)
+        Some(ctor.newInstance(args: _*).asInstanceOf[T])
+      case None => None
+    }
   } catch {
     case e: Exception =>
       None
   }
 
   def getObjectFor[T](fqn: String, classloader: ClassLoader = loader): Option[T] = try {//Obtains a reference to $MODULE$
-    assert(fqn ne null)
-    val clazz = classloader.loadClass(fqn)
-    val instance = clazz.getDeclaredField("MODULE$")
-    instance.setAccessible(true)
-    Option(instance.get(null).asInstanceOf[T])
+    getClassFor(fqn) match {
+      case Some(clazz) =>
+        val instance = clazz.getDeclaredField("MODULE$")
+        instance.setAccessible(true)
+        Option(instance.get(null).asInstanceOf[T])
+      case None => None
+    }
   } catch {
-    case e: ClassNotFoundException =>
-      None
     case ei: ExceptionInInitializerError =>
       throw ei
   }
 
-  def getClassFor[T](fqn: String, classloader: ClassLoader = loader): Option[Class[T]] = try {
+  def getClassFor[T](fqn: String, classloader: ClassLoader = loader): Option[Class[T]] = {
     assert(fqn ne null)
-    Some(classloader.loadClass(fqn).asInstanceOf[Class[T]])
-  } catch {
-    case e: Exception =>
-      None
+
+    def tryLoad(f: => Class[T]): Option[Class[T]] = try {
+      Option(f)
+    } catch {
+      case cnfe: ClassNotFoundException => None
+    }
+
+    tryLoad(classloader.loadClass(fqn).asInstanceOf[Class[T]]) orElse
+    tryLoad(Thread.currentThread.getContextClassLoader.loadClass(fqn).asInstanceOf[Class[T]])
+    tryLoad(this.getClass.getClassLoader.loadClass(fqn).asInstanceOf[Class[T]]) orElse
+    tryLoad(Class.forName(fqn).asInstanceOf[Class[T]])
   }
 }
diff --git a/akka-remote/src/main/scala/akka/remote/netty/NettyRemoteSupport.scala b/akka-remote/src/main/scala/akka/remote/netty/NettyRemoteSupport.scala
index 484781d68d..893b22b059 100644
--- a/akka-remote/src/main/scala/akka/remote/netty/NettyRemoteSupport.scala
+++ b/akka-remote/src/main/scala/akka/remote/netty/NettyRemoteSupport.scala
@@ -856,6 +856,8 @@ class RemoteServerHandler(
     }
 
   private def handleRemoteMessageProtocol(request: RemoteMessageProtocol, channel: Channel) = {
+    //FIXME we should definitely spawn off this in a thread pool or something,
+    //      potentially using Actor.spawn or something similar
     request.getActorInfo.getActorType match {
       case SCALA_ACTOR => dispatchToActor(request, channel)
       case TYPED_ACTOR => dispatchToTypedActor(request, channel)