diff --git a/Modules/Multilabel/mitkLabelSetImageHelper.cpp b/Modules/Multilabel/mitkLabelSetImageHelper.cpp
index 956d06a55f..6aa795e9dc 100644
--- a/Modules/Multilabel/mitkLabelSetImageHelper.cpp
+++ b/Modules/Multilabel/mitkLabelSetImageHelper.cpp
@@ -1,149 +1,149 @@
 /*============================================================================
 
 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 <mitkLabelSetImageHelper.h>
 
 #include <mitkLabelSetImage.h>
 #include <mitkExceptionMacro.h>
 #include <mitkProperties.h>
 
 #include <array>
 #include <regex>
 #include <vector>
 
 namespace
 {
   template <typename T>
   std::array<int, 3> QuantizeColor(const T* color)
   {
     return {
       static_cast<int>(std::round(color[0] * 255)),
       static_cast<int>(std::round(color[1] * 255)),
       static_cast<int>(std::round(color[2] * 255)) };
   }
 
   mitk::Color FromLookupTableColor(const double* lookupTableColor)
   {
     mitk::Color color;
     color.Set(
       static_cast<float>(lookupTableColor[0]),
       static_cast<float>(lookupTableColor[1]),
       static_cast<float>(lookupTableColor[2]));
     return color;
   }
 }
 
 mitk::DataNode::Pointer mitk::LabelSetImageHelper::CreateNewSegmentationNode(const DataNode* referenceNode,
   const Image* initialSegmentationImage, const std::string& segmentationName)
 {
   std::string newSegmentationName = segmentationName;
   if (newSegmentationName.empty())
   {
     newSegmentationName = referenceNode->GetName();
     newSegmentationName.append("-labels");
   }
 
   if (nullptr == initialSegmentationImage)
   {
     return nullptr;
   }
 
   auto newLabelSetImage = mitk::LabelSetImage::New();
   try
   {
     newLabelSetImage->Initialize(initialSegmentationImage);
   }
   catch (mitk::Exception &e)
   {
     mitkReThrow(e) << "Could not initialize new label set image.";
     return nullptr;
   }
 
   auto newSegmentationNode = mitk::DataNode::New();
   newSegmentationNode->SetData(newLabelSetImage);
   newSegmentationNode->SetName(newSegmentationName);
 
   // set additional image information
   newLabelSetImage->GetExteriorLabel()->SetProperty("name.parent", mitk::StringProperty::New(referenceNode->GetName()));
   newLabelSetImage->GetExteriorLabel()->SetProperty("name.image", mitk::StringProperty::New(newSegmentationName));
 
   // initialize "showVolume"-property to false to prevent recalculating the volume while working on the segmentation
   newSegmentationNode->SetProperty("showVolume", mitk::BoolProperty::New(false));
 
   return newSegmentationNode;
 }
 
 mitk::Label::Pointer mitk::LabelSetImageHelper::CreateNewLabel(const LabelSetImage* labelSetImage)
 {
   if (nullptr == labelSetImage)
     return nullptr;
 
-  const std::regex genericLabelNameRegEx("New label ([1-9][0-9]*)");
+  const std::regex genericLabelNameRegEx("Label ([1-9][0-9]*)");
   int maxGenericLabelNumber = 0;
 
   std::vector<std::array<int, 3>> colorsInUse;
 
   const auto numLabelSets = labelSetImage->GetNumberOfLayers();
 
   for (std::remove_const_t<decltype(numLabelSets)> i = 0; i < numLabelSets; ++i)
   {
     auto labelSet = labelSetImage->GetLabelSet(i);
     auto labelEndIter = labelSet->IteratorConstEnd();
 
     for (auto labelIter = labelSet->IteratorConstBegin(); labelIter != labelEndIter; ++labelIter)
     {
       auto label = labelIter->second;
       auto labelName = label->GetName();
       std::smatch match;
 
       if (std::regex_match(labelName, match, genericLabelNameRegEx))
         maxGenericLabelNumber = std::max(maxGenericLabelNumber, std::stoi(match[1].str()));
 
       const auto quantizedLabelColor = QuantizeColor(label->GetColor().data());
 
       if (std::find(colorsInUse.begin(), colorsInUse.end(), quantizedLabelColor) == std::end(colorsInUse))
         colorsInUse.push_back(quantizedLabelColor);
     }
   }
 
   auto newLabel = mitk::Label::New();
-  newLabel->SetName("New label " + std::to_string(maxGenericLabelNumber + 1));
+  newLabel->SetName("Label " + std::to_string(maxGenericLabelNumber + 1));
 
   auto lookupTable = mitk::LookupTable::New();
   lookupTable->SetType(mitk::LookupTable::LookupTableType::MULTILABEL);
 
   std::array<double, 3> lookupTableColor;
   const int maxTries = 25;
   bool newColorFound = false;
 
   for (int i = 0; i < maxTries; ++i)
   {
     lookupTable->GetColor(i, lookupTableColor.data());
 
     auto quantizedLookupTableColor = QuantizeColor(lookupTableColor.data());
 
     if (std::find(colorsInUse.begin(), colorsInUse.end(), quantizedLookupTableColor) == std::end(colorsInUse))
     {
       newLabel->SetColor(FromLookupTableColor(lookupTableColor.data()));
       newColorFound = true;
       break;
     }
   }
 
   if (!newColorFound)
   {
     lookupTable->GetColor(labelSetImage->GetTotalNumberOfLabels(), lookupTableColor.data());
     newLabel->SetColor(FromLookupTableColor(lookupTableColor.data()));
   }
 
   return newLabel;
 }