diff --git a/Plugins/org.mitk.gui.qt.common/src/QmitkNodeSelectionButton.cpp b/Plugins/org.mitk.gui.qt.common/src/QmitkNodeSelectionButton.cpp
index 9f927b0d47..cdb8ca7041 100644
--- a/Plugins/org.mitk.gui.qt.common/src/QmitkNodeSelectionButton.cpp
+++ b/Plugins/org.mitk.gui.qt.common/src/QmitkNodeSelectionButton.cpp
@@ -1,218 +1,263 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 
 #include "QmitkNodeSelectionButton.h"
 
 // berry includes
 #include <berryWorkbenchPlugin.h>
 #include <berryQtStyleManager.h>
 
 #include "QPainter"
 #include "QTextDocument"
 #include "QEvent"
 
 #include <mitkDataNode.h>
 #include <QmitkNodeDescriptorManager.h>
 
 // mitk core
 #include <mitkBaseRenderer.h>
 #include <mitkDataNode.h>
 #include <mitkExtractSliceFilter.h>
 #include <vtkMitkLevelWindowFilter.h>
 #include <mitkPlanarFigure.h>
 #include <mitkPropertyNameHelper.h>
 
 // vtk
 #include <vtkLookupTable.h>
 
 QPixmap GetPixmapFromImageNode(const mitk::DataNode* dataNode, int height)
 {
   if (nullptr == dataNode)
   {
     return QPixmap();
   }
 
   const mitk::Image* image = dynamic_cast<const mitk::Image*>(dataNode->GetData());
   if ((nullptr == image || !image->IsInitialized()) || // -> must be an image
     (image->GetPixelType().GetNumberOfComponents() != 1)) // -> for now only single component are allowed
   {
     auto descManager = QmitkNodeDescriptorManager::GetInstance();
     auto desc = descManager->GetDescriptor(dataNode);
     auto icon = desc->GetIcon(dataNode);
     auto fallBackMap = icon.pixmap(height, height);
     return fallBackMap;
   }
 
   mitk::PlaneGeometry::Pointer planeGeometry = mitk::PlaneGeometry::New();
   int sliceNumber = image->GetDimension(2) / 2;
   planeGeometry->InitializeStandardPlane(image->GetGeometry(), mitk::PlaneGeometry::Axial, sliceNumber);
 
   mitk::ExtractSliceFilter::Pointer extractSliceFilter = mitk::ExtractSliceFilter::New();
   extractSliceFilter->SetInput(image);
   extractSliceFilter->SetInterpolationMode(mitk::ExtractSliceFilter::RESLICE_CUBIC);
   extractSliceFilter->SetResliceTransformByGeometry(image->GetGeometry());
   extractSliceFilter->SetWorldGeometry(planeGeometry);
   extractSliceFilter->SetOutputDimensionality(2);
   extractSliceFilter->SetVtkOutputRequest(true);
   extractSliceFilter->Update();
 
   vtkImageData* imageData = extractSliceFilter->GetVtkOutput();
 
   mitk::LevelWindow levelWindow;
   dataNode->GetLevelWindow(levelWindow);
   vtkSmartPointer<vtkLookupTable> lookupTable = vtkSmartPointer<vtkLookupTable>::New();
   lookupTable->SetRange(levelWindow.GetLowerWindowBound(), levelWindow.GetUpperWindowBound());
   lookupTable->SetSaturationRange(0.0, 0.0);
   lookupTable->SetValueRange(0.0, 1.0);
   lookupTable->SetHueRange(0.0, 0.0);
   lookupTable->SetRampToLinear();
 
   vtkSmartPointer<vtkMitkLevelWindowFilter> levelWindowFilter = vtkSmartPointer<vtkMitkLevelWindowFilter>::New();
   levelWindowFilter->SetLookupTable(lookupTable);
   levelWindowFilter->SetInputData(imageData);
   levelWindowFilter->SetMinOpacity(0.0);
   levelWindowFilter->SetMaxOpacity(1.0);
   int dims[3];
   imageData->GetDimensions(dims);
   double clippingBounds[] = { 0.0, static_cast<double>(dims[0]), 0.0, static_cast<double>(dims[1]) };
   levelWindowFilter->SetClippingBounds(clippingBounds);
   levelWindowFilter->Update();
   imageData = levelWindowFilter->GetOutput();
 
   QImage thumbnailImage(reinterpret_cast<const unsigned char*>(imageData->GetScalarPointer()), dims[0], dims[1], QImage::Format_ARGB32);
 
   thumbnailImage = thumbnailImage.scaledToHeight(height,Qt::SmoothTransformation).rgbSwapped();
   return QPixmap::fromImage(thumbnailImage);
 }
 
 QmitkNodeSelectionButton::QmitkNodeSelectionButton(QWidget *parent)
-  : QPushButton(parent), m_OutDatedThumpNail(true), m_IsOptional(true)
+  : QPushButton(parent), m_OutDatedThumpNail(true), m_IsOptional(true), m_NodeModifiedObserverTag(0), m_NodeObserved(false)
 { }
 
 QmitkNodeSelectionButton::~QmitkNodeSelectionButton()
 {
+  this->RemoveNodeObserver();
   this->m_SelectedNode = nullptr;
 }
 
+void QmitkNodeSelectionButton::AddNodeObserver()
+{
+  if (this->m_SelectedNode.IsNotNull())
+  {
+    if (m_NodeObserved)
+    {
+      MITK_DEBUG << "Invalid observer state in QmitkNodeSelectionButton. There is already a registered observer. Internal logic is not correct. May be an old observer was not removed.";
+    }
+
+    auto modifiedCommand = itk::MemberCommand<QmitkNodeSelectionButton>::New();
+    modifiedCommand->SetCallbackFunction(this, &QmitkNodeSelectionButton::OnNodeModified);
+
+    // const cast because we need non const nodes and it seems to be the lesser of two evil.
+    // the changes to the node are only on the observer level. The other option would be to
+    // make the public interface require non const nodes, this we don't want to introduce.
+    auto nonconst_node = const_cast<mitk::DataNode*>(this->m_SelectedNode.GetPointer());
+    m_NodeModifiedObserverTag = nonconst_node->AddObserver(itk::ModifiedEvent(), modifiedCommand);
+    m_NodeObserved = true;
+  }
+}
+
+void QmitkNodeSelectionButton::RemoveNodeObserver()
+{
+  if (this->m_SelectedNode.IsNotNull())
+  {
+    // const cast because we need non const nodes and it seems to be the lesser of two evil.
+    // the changes to the node are only on the observer level. The other option would be to
+    // make the public interface require non const nodes, this we don't want to introduce.
+    auto nonconst_node = const_cast<mitk::DataNode*>(this->m_SelectedNode.GetPointer());
+    nonconst_node->RemoveObserver(m_NodeModifiedObserverTag);
+  }
+  m_NodeObserved = false;
+}
+
+void QmitkNodeSelectionButton::OnNodeModified(const itk::Object * /*caller*/, const itk::EventObject & event)
+{
+  if (itk::ModifiedEvent().CheckEvent(&event))
+  {
+    this->repaint();
+  }
+}
+
 const mitk::DataNode* QmitkNodeSelectionButton::GetSelectedNode() const
 {
   return m_SelectedNode;
 }
 
 void QmitkNodeSelectionButton::SetSelectedNode(const mitk::DataNode* node)
 {
   if (m_SelectedNode != node)
   {
+    this->RemoveNodeObserver();
     this->m_SelectedNode = node;
     this->m_OutDatedThumpNail = true;
+    this->AddNodeObserver();
   }
 
   this->update();
 }
 
 void QmitkNodeSelectionButton::SetNodeInfo(QString info)
 {
   this->m_Info = info;
   this->update();
 }
 
 void QmitkNodeSelectionButton::paintEvent(QPaintEvent *p)
 {
   QString stylesheet;
 
   ctkPluginContext* context = berry::WorkbenchPlugin::GetDefault()->GetPluginContext();
   ctkServiceReference styleManagerRef = context->getServiceReference<berry::IQtStyleManager>();
   if (styleManagerRef)
   {
     auto styleManager = context->getService<berry::IQtStyleManager>(styleManagerRef);
     stylesheet = styleManager->GetStylesheet();
   }
 
   QPushButton::paintEvent(p);
 
   QPainter painter(this);
   QTextDocument td(this);
   td.setDefaultStyleSheet(stylesheet);
 
   auto widgetSize = this->size();
   QPoint origin = QPoint(5, 5);
 
   if (this->m_SelectedNode)
   {
     auto iconLength = widgetSize.height() - 10;
     auto node = this->m_SelectedNode;
 
     if (this->m_OutDatedThumpNail)
     {
       this->m_ThumpNail = GetPixmapFromImageNode(node, iconLength);
       this->m_OutDatedThumpNail = false;
     }
 
     painter.drawPixmap(origin, m_ThumpNail);
     origin.setX(origin.x() + iconLength + 5);
 
     if (this->isEnabled())
     {
       td.setHtml(QString::fromStdString("<font class=\"normal\">" + node->GetName() + "</font>"));
     }
     else
     {
       td.setHtml(QString::fromStdString("<font class=\"disabled\">" + node->GetName() + "</font>"));
     }
   }
   else
   {
     if (this->isEnabled())
     {
       if (this->m_IsOptional)
       {
         td.setHtml(QString("<font class=\"normal\">") + m_Info + QString("</font>"));
       }
       else
       {
         td.setHtml(QString("<font class=\"warning\">") + m_Info + QString("</font>"));
       }
     }
     else
     {
       td.setHtml(QString("<font class=\"disabled\">") + m_Info + QString("</font>"));
     }
   }
 
   auto textSize = td.size();
 
   origin.setY( (widgetSize.height() - textSize.height()) / 2.);
 
   painter.translate(origin);
   td.drawContents(&painter);
 
 }
 
 void QmitkNodeSelectionButton::changeEvent(QEvent *event)
 {
   if (event->type() == QEvent::EnabledChange)
   {
     this->repaint();
   }
 }
 
 bool QmitkNodeSelectionButton::GetSelectionIsOptional() const
 {
   return m_IsOptional;
 }
 
 void QmitkNodeSelectionButton::SetSelectionIsOptional(bool isOptional)
 {
   m_IsOptional = isOptional;
   this->repaint();
 }
diff --git a/Plugins/org.mitk.gui.qt.common/src/QmitkNodeSelectionButton.h b/Plugins/org.mitk.gui.qt.common/src/QmitkNodeSelectionButton.h
index 98974a6b0c..dc851cf409 100644
--- a/Plugins/org.mitk.gui.qt.common/src/QmitkNodeSelectionButton.h
+++ b/Plugins/org.mitk.gui.qt.common/src/QmitkNodeSelectionButton.h
@@ -1,63 +1,71 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 
 #ifndef QMITK_NODE_SELECTION_BUTTON_H
 #define QMITK_NODE_SELECTION_BUTTON_H
 
 #include <mitkWeakPointer.h>
 #include <mitkDataNode.h>
 
 #include "org_mitk_gui_qt_common_Export.h"
 
 #include "QPushButton"
 #include "QPixmap"
 
 
 /** Button class that can be used to display informations about a passed node.
  * If the passed node is a null ptr the node info text will be shown.
  * In difference to the normal push button text property. The node info can
  * be formated text (e.g. HTML code; like the tooltip text).*/
 class MITK_QT_COMMON QmitkNodeSelectionButton : public QPushButton
 {
   Q_OBJECT
 
 public:
   explicit QmitkNodeSelectionButton(QWidget *parent = nullptr);
   ~QmitkNodeSelectionButton() override;
 
   const mitk::DataNode* GetSelectedNode() const;
   bool GetSelectionIsOptional() const;
 
 public Q_SLOTS :
   virtual void SetSelectedNode(const mitk::DataNode* node);
   virtual void SetNodeInfo(QString info);
 
   /** Set the widget into an optional mode. Optional means that the selection of no valid
   node does not mean an invalid state. Thus no node is a valid "node" selection too.
   The state influences if the info text is handled as an information (optional) or a
   warning (optiona==false).*/
   void SetSelectionIsOptional(bool isOptional);
 
 protected:
   void paintEvent(QPaintEvent *p) override;
   void changeEvent(QEvent *event) override;
 
+  void AddNodeObserver();
+  void RemoveNodeObserver();
+  void OnNodeModified(const itk::Object * /*caller*/, const itk::EventObject &);
+
   mitk::DataNode::ConstPointer m_SelectedNode;
   QString m_Info;
   bool m_OutDatedThumpNail;
   QPixmap m_ThumpNail;
+
   bool m_IsOptional;
+
+  unsigned long m_NodeModifiedObserverTag;
+  bool m_NodeObserved;
 };
 
 
 #endif // QmitkSingleNodeSelectionWidget_H