diff --git a/Modules/Core/src/Rendering/mitkMapper.cpp b/Modules/Core/src/Rendering/mitkMapper.cpp
index 4865361237..6a690f796a 100644
--- a/Modules/Core/src/Rendering/mitkMapper.cpp
+++ b/Modules/Core/src/Rendering/mitkMapper.cpp
@@ -1,214 +1,216 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkBaseRenderer.h"
 #include "mitkDataNode.h"
 #include "mitkMapper.h"
 #include "mitkProperties.h"
 #include "usGetModuleContext.h"
 #include "usLDAPProp.h"
 #include "usPrototypeServiceFactory.h"
+#include <usServiceEvent.h>
 
 mitk::Mapper::Mapper() : m_DataNode(nullptr), m_TimeStep(0) {}
 
 mitk::Mapper::~Mapper() {}
 
 mitk::BaseData *mitk::Mapper::GetData() const
 {
   return m_DataNode == nullptr ? nullptr : m_DataNode->GetData();
 }
 
 us::ServiceRegistration<mitk::Mapper> mitk::Mapper::RegisterAtServiceRegistry(
   std::string supportedDataTypeName, mitk::BaseRenderer::MapperSlotId supportedSlot, int priority)
 {
   // Check if a prototype factory for this specific mapper type already exists
-  std::string className = this->GetNameOfClass();//typeid(*this).name();
-  
+  std::string className = this->GetNameOfClass(); // typeid(*this).name();
+
   auto context = us::GetModuleContext();
-  auto refs = context->GetServiceReferences<Mapper>(us::LDAPProp("PROP_CLASS_NAME") == className);
+  auto refs = context->GetServiceReferences<Mapper>(us::LDAPProp("PROP_CLASS_NAME") == className && us::LDAPProp("PROP_SLOT_ID") == supportedSlot);
   const bool alreadyExists = !refs.empty();
 
   struct PrototypeFactory : public us::PrototypeServiceFactory
   {
     itk::SmartPointer<mitk::Mapper> const m_Prototype;
     std::vector<itk::SmartPointer<mitk::Mapper>> m_CreatedObjects;
 
     PrototypeFactory(itk::SmartPointer<mitk::Mapper> prototype)
       : m_Prototype(prototype), m_CreatedObjects(std::vector<itk::SmartPointer<mitk::Mapper>>())
     {
     }
     us::InterfaceMap GetService(us::Module * /*module*/, const us::ServiceRegistrationBase & /*registration*/) override
     {
       auto another = m_Prototype->CreateAnother();
       Mapper *rawPointer = dynamic_cast<Mapper *>(another.GetPointer());
 
       assert(rawPointer != nullptr);
 
       m_CreatedObjects.push_back(rawPointer);
 
       return us::MakeInterfaceMap<Mapper>(rawPointer);
     }
 
     void UngetService(us::Module * /*module*/,
                       const us::ServiceRegistrationBase & /*registration*/,
                       const us::InterfaceMap &service) override
     {
       MITK_INFO << "UngetService in mapper factory";
-      Mapper* mapperToRemove = us::ExtractInterface<Mapper>(service);
+      Mapper *mapperToRemove = us::ExtractInterface<Mapper>(service);
       for (auto iter = m_CreatedObjects.begin(); iter != m_CreatedObjects.end(); ++iter)
       {
-        if(iter->GetPointer() == mapperToRemove)
+        if (iter->GetPointer() == mapperToRemove)
         {
           m_CreatedObjects.erase(iter);
           break;
         }
       }
     }
   };
 
   auto registration = us::ServiceRegistration<Mapper>();
   // Only create a new factory once
   if (!alreadyExists)
   {
     // Todo check if CppMicroservices frees this memory when the factory is unregistered
     auto prototypeFactory = new PrototypeFactory(this);
     us::ServiceProperties props{std::make_pair("PROP_CLASS_NAME", className),
-                                std::make_pair("PROP_SUPPORTED_DATA_TYPE_NAME", supportedDataTypeName),
-                                std::make_pair("PROP_SUPPORTED_SLOT_ID", supportedSlot),
+                                std::make_pair("PROP_DATA_TYPE_NAME", supportedDataTypeName),
+                                std::make_pair("PROP_SLOT_ID", supportedSlot),
                                 std::make_pair("PROP_PRIORITY", priority)};
     registration = context->RegisterService<Mapper>(prototypeFactory, props);
   }
+
   return registration;
 }
 
 mitk::DataNode *mitk::Mapper::GetDataNode() const
 {
   return this->m_DataNode;
 }
 
 bool mitk::Mapper::GetColor(float rgb[3], mitk::BaseRenderer *renderer, const char *name) const
 {
   const mitk::DataNode *node = GetDataNode();
   if (node == nullptr)
     return false;
 
   return node->GetColor(rgb, renderer, name);
 }
 
 bool mitk::Mapper::GetVisibility(bool &visible, mitk::BaseRenderer *renderer, const char *name) const
 {
   const mitk::DataNode *node = GetDataNode();
   if (node == nullptr)
     return false;
 
   return node->GetVisibility(visible, renderer, name);
 }
 
 bool mitk::Mapper::GetOpacity(float &opacity, mitk::BaseRenderer *renderer, const char *name) const
 {
   const mitk::DataNode *node = GetDataNode();
   if (node == nullptr)
     return false;
 
   return node->GetOpacity(opacity, renderer, name);
 }
 
 bool mitk::Mapper::GetLevelWindow(mitk::LevelWindow &levelWindow, mitk::BaseRenderer *renderer, const char *name) const
 {
   const mitk::DataNode *node = GetDataNode();
   if (node == nullptr)
     return false;
 
   return node->GetLevelWindow(levelWindow, renderer, name);
 }
 
 bool mitk::Mapper::IsVisible(mitk::BaseRenderer *renderer, const char *name) const
 {
   bool visible = true;
   GetDataNode()->GetVisibility(visible, renderer, name);
   return visible;
 }
 
 void mitk::Mapper::CalculateTimeStep(mitk::BaseRenderer *renderer)
 {
   if ((renderer != nullptr) && (m_DataNode != nullptr))
   {
     m_TimeStep = renderer->GetTimeStep(m_DataNode->GetData());
   }
   else
   {
     m_TimeStep = 0;
   }
 }
 
 void mitk::Mapper::Update(mitk::BaseRenderer *renderer)
 {
   const DataNode *node = GetDataNode();
 
   assert(node != nullptr);
 
   auto *data = static_cast<mitk::BaseData *>(node->GetData());
 
   if (!data)
     return;
 
   // Calculate time step of the input data for the specified renderer (integer value)
   this->CalculateTimeStep(renderer);
 
   // Check if time step is valid
   const TimeGeometry *dataTimeGeometry = data->GetTimeGeometry();
   if ((dataTimeGeometry == nullptr) || (dataTimeGeometry->CountTimeSteps() == 0) ||
       (!dataTimeGeometry->IsValidTimeStep(m_TimeStep)))
   {
     // TimeGeometry or time step is not valid for this data:
     // reset mapper so that nothing is displayed
     this->ResetMapper(renderer);
     return;
   }
 
   this->GenerateDataForRenderer(renderer);
 }
 
 bool mitk::Mapper::BaseLocalStorage::IsGenerateDataRequired(mitk::BaseRenderer *renderer,
                                                             mitk::Mapper *mapper,
                                                             mitk::DataNode *dataNode) const
 {
   if (mapper && m_LastGenerateDataTime < mapper->GetMTime())
     return true;
 
   if (dataNode)
   {
     if (m_LastGenerateDataTime < dataNode->GetDataReferenceChangedTime())
       return true;
 
     mitk::BaseData *data = dataNode->GetData();
 
     if (data && m_LastGenerateDataTime < data->GetMTime())
       return true;
   }
 
   if (renderer && m_LastGenerateDataTime < renderer->GetTimeStepUpdateTime())
     return true;
 
   return false;
 }
 
 void mitk::Mapper::SetDefaultProperties(mitk::DataNode *node, mitk::BaseRenderer *renderer, bool overwrite)
 {
   node->AddProperty("visible", mitk::BoolProperty::New(true), renderer, overwrite);
   node->AddProperty("layer", mitk::IntProperty::New(0), renderer, overwrite);
   node->AddProperty("name", mitk::StringProperty::New("No Name!"), renderer, overwrite);
 }