diff --git a/akka-actor/src/main/scala/akka/event/EventHandler.scala b/akka-actor/src/main/scala/akka/event/EventHandler.scala
index 3fd2f02be5..fe75a31dc0 100644
--- a/akka-actor/src/main/scala/akka/event/EventHandler.scala
+++ b/akka-actor/src/main/scala/akka/event/EventHandler.scala
@@ -5,8 +5,6 @@
 package akka.event
 
 import akka.actor._
-import Actor._
-import akka.dispatch._
 import akka.config.Config._
 import akka.config.ConfigurationException
 import akka.util.{ListenerManagement, ReflectiveAccess}
@@ -39,11 +37,11 @@ import akka.AkkaException
  * <p/>
  * Log an error event:
  * <pre>
- * EventHandler.notify(EventHandler.Error(exception, this, message.toString))
+ * EventHandler.notify(EventHandler.Error(exception, this, message))
  * </pre>
  * Or use the direct methods (better performance):
  * <pre>
- * EventHandler.error(exception, this, message.toString)
+ * EventHandler.error(exception, this, message)
  * </pre>
  *
  * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
@@ -61,11 +59,20 @@ object EventHandler extends ListenerManagement {
 
   sealed trait Event {
     @transient val thread: Thread = Thread.currentThread
+    val level: Int
+  }
+  case class Error(cause: Throwable, instance: AnyRef, message: Any = "") extends Event {
+    override val level = ErrorLevel
+  }
+  case class Warning(instance: AnyRef, message: Any = "") extends Event {
+    override val level = WarningLevel
+  }
+  case class Info(instance: AnyRef, message: Any = "") extends Event {
+    override val level = InfoLevel
+  }
+  case class Debug(instance: AnyRef, message: Any = "") extends Event {
+    override val level = DebugLevel
   }
-  case class Error(cause: Throwable, instance: AnyRef, message: String = "") extends Event
-  case class Warning(instance: AnyRef, message: String = "") extends Event
-  case class Info(instance: AnyRef, message: String = "") extends Event
-  case class Debug(instance: AnyRef, message: String = "") extends Event
 
   val error   = "[ERROR]   [%s] [%s] [%s] %s\n%s".intern
   val warning = "[WARN]    [%s] [%s] [%s] %s".intern
@@ -87,29 +94,49 @@ object EventHandler extends ListenerManagement {
                     "Configuration option 'akka.event-handler-level' is invalid [" + unknown + "]")
   }
 
-  def notify(event: => AnyRef) = notifyListeners(event)
+  def notify(event: Any) { notifyListeners(event) }
 
-  def notify[T <: Event : ClassManifest](event: => T) {
-    if (level >= levelFor(classManifest[T].erasure.asInstanceOf[Class[_ <: Event]])) notifyListeners(event)
+  def notify(event: Event) {
+    if (level >= event.level) notifyListeners(event)
   }
 
-  def error(cause: Throwable, instance: AnyRef, message: => String) = {
+  def error(cause: Throwable, instance: AnyRef, message: => String) {
     if (level >= ErrorLevel) notifyListeners(Error(cause, instance, message))
   }
 
-  def error(instance: AnyRef, message: => String) = {
+  def error(cause: Throwable, instance: AnyRef, message: Any) {
+    if (level >= ErrorLevel) notifyListeners(Error(cause, instance, message))
+  }
+
+  def error(instance: AnyRef, message: => String) {
     if (level >= ErrorLevel) notifyListeners(Error(new EventHandlerException, instance, message))
   }
 
-  def warning(instance: AnyRef, message: => String) = {
+  def error(instance: AnyRef, message: Any) {
+    if (level >= ErrorLevel) notifyListeners(Error(new EventHandlerException, instance, message))
+  }
+
+  def warning(instance: AnyRef, message: => String) {
     if (level >= WarningLevel) notifyListeners(Warning(instance, message))
   }
 
-  def info(instance: AnyRef, message: => String) = {
+  def warning(instance: AnyRef, message: Any) {
+    if (level >= WarningLevel) notifyListeners(Warning(instance, message))
+  }
+
+  def info(instance: AnyRef, message: => String) {
     if (level >= InfoLevel) notifyListeners(Info(instance, message))
   }
 
-  def debug(instance: AnyRef, message: => String) = {
+  def info(instance: AnyRef, message: Any) {
+    if (level >= InfoLevel) notifyListeners(Info(instance, message))
+  }
+
+  def debug(instance: AnyRef, message: => String) {
+    if (level >= DebugLevel) notifyListeners(Debug(instance, message))
+  }
+
+  def debug(instance: AnyRef, message: Any) {
     if (level >= DebugLevel) notifyListeners(Debug(instance, message))
   }
 
@@ -122,14 +149,6 @@ object EventHandler extends ListenerManagement {
     sw.toString
   }
 
-  private def levelFor(eventClass: Class[_ <: Event]) = {
-    if (eventClass.isInstanceOf[Error])        ErrorLevel
-    else if (eventClass.isInstanceOf[Warning]) WarningLevel
-    else if (eventClass.isInstanceOf[Info])    InfoLevel
-    else if (eventClass.isInstanceOf[Debug])   DebugLevel
-    else                                       DebugLevel
-  }
-
   class DefaultListener extends Actor {
     self.id = ID
     self.dispatcher = EventHandlerDispatcher
diff --git a/akka-actor/src/main/scala/akka/remoteinterface/RemoteInterface.scala b/akka-actor/src/main/scala/akka/remoteinterface/RemoteInterface.scala
index e9e4168995..29d8185ef2 100644
--- a/akka-actor/src/main/scala/akka/remoteinterface/RemoteInterface.scala
+++ b/akka-actor/src/main/scala/akka/remoteinterface/RemoteInterface.scala
@@ -20,7 +20,7 @@ trait RemoteModule {
   val UUID_PREFIX = "uuid:".intern
 
   def optimizeLocalScoped_?(): Boolean //Apply optimizations for remote operations in local scope
-  protected[akka] def notifyListeners(message: => Any): Unit
+  protected[akka] def notifyListeners(message: Any): Unit
 
   private[akka] def actors: ConcurrentHashMap[String, ActorRef]
   private[akka] def actorsByUuid: ConcurrentHashMap[String, ActorRef]
@@ -227,7 +227,7 @@ abstract class RemoteSupport extends ListenerManagement with RemoteServerModule
   }
 
   protected override def manageLifeCycleOfListeners = false
-  protected[akka] override def notifyListeners(message: => Any): Unit = super.notifyListeners(message)
+  protected[akka] override def notifyListeners(message: Any): Unit = super.notifyListeners(message)
 
   private[akka] val actors               = new ConcurrentHashMap[String, ActorRef]
   private[akka] val actorsByUuid         = new ConcurrentHashMap[String, ActorRef]
diff --git a/akka-actor/src/main/scala/akka/util/ListenerManagement.scala b/akka-actor/src/main/scala/akka/util/ListenerManagement.scala
index 916fac9c6a..9417f954ee 100644
--- a/akka-actor/src/main/scala/akka/util/ListenerManagement.scala
+++ b/akka-actor/src/main/scala/akka/util/ListenerManagement.scala
@@ -50,13 +50,12 @@ trait ListenerManagement {
    */
   def hasListener(listener: ActorRef): Boolean = listeners.contains(listener)
 
-  protected[akka] def notifyListeners(message: => Any) {
+  protected[akka] def notifyListeners(message: Any) {
     if (hasListeners) {
-      val msg = message
       val iterator = listeners.iterator
       while (iterator.hasNext) {
         val listener = iterator.next
-        if (listener.isRunning) listener ! msg
+        if (listener.isRunning) listener ! message
       }
     }
   }
diff --git a/akka-slf4j/src/main/scala/akka/event/slf4j/SLF4J.scala b/akka-slf4j/src/main/scala/akka/event/slf4j/SLF4J.scala
index fa1d4e713e..b8fb70f491 100644
--- a/akka-slf4j/src/main/scala/akka/event/slf4j/SLF4J.scala
+++ b/akka-slf4j/src/main/scala/akka/event/slf4j/SLF4J.scala
@@ -39,7 +39,7 @@ class Slf4jEventHandler extends Actor with Logging {
   def receive = {
     case Error(cause, instance, message) =>
       log.error("\n\t[{}]\n\t[{}]\n\t[{}]",
-                Array[AnyRef](instance.getClass.getName, message, stackTraceFor(cause)))
+                Array[Any](instance.getClass.getName, message, stackTraceFor(cause)))
 
     case Warning(instance, message) =>
       log.warn("\n\t[{}]\n\t[{}]", instance.getClass.getName, message)