diff --git a/Modules/REST/src/mitkRESTClient.cpp b/Modules/REST/src/mitkRESTClient.cpp
index ee3afbba22..7c1405fc77 100644
--- a/Modules/REST/src/mitkRESTClient.cpp
+++ b/Modules/REST/src/mitkRESTClient.cpp
@@ -1,183 +1,177 @@
 /*===================================================================
 
 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 <mitkRESTClient.h>
 #include <mitkRESTUtil.h>
 #include <mitkExceptionMacro.h>
 
 #include <cpprest/http_client.h>
 #include <cpprest/filestream.h>
 
 using http_client = web::http::client::http_client;
 using http_request = web::http::http_request;
 using http_response = web::http::http_response;
 using methods = web::http::methods;
 using status_codes = web::http::status_codes;
 using file_buffer = concurrency::streams::file_buffer<uint8_t>;
 using streambuf = concurrency::streams::streambuf<uint8_t>;
 
 mitk::RESTClient::RESTClient()
 {
 }
 
 mitk::RESTClient::~RESTClient()
 {
 }
 
 pplx::task<web::json::value> mitk::RESTClient::Get(const web::uri &uri,
                                                    const std::map<utility::string_t, utility::string_t> headers)
 {
-  MITK_INFO << "within client no file path with uri: " << mitk::RESTUtil::convertToUtf8(uri.to_string());
+  MITK_DEBUG << "Executing GET with URI: " << mitk::RESTUtil::convertToUtf8(uri.to_string());
   auto client = new http_client(uri);
-  MITK_INFO << "after creating a client";
   http_request request;
-  //request.set_request_uri(uri);
 
   for (auto param : headers)
   {
     request.headers().add(param.first, param.second);
   }
 
-  MITK_INFO << mitk::RESTUtil::convertToUtf8(request.absolute_uri().to_string());
-
   return client->request(request).then([=](pplx::task<web::http::http_response> responseTask) {
     try
     {
       auto response = responseTask.get();
       auto status = response.status_code();
 
-      MITK_INFO << status;
-
       if (status_codes::OK != status)
         mitkThrow();
 
       auto requestContentType = response.headers().content_type();
 
       if (_XPLATSTR("application/json") != requestContentType)
         response.headers().set_content_type(_XPLATSTR("application/json"));
 
       return response.extract_json().get();
     }
     catch (...)
     {
       mitkThrow() << "Getting response went wrong";
     }
   });
 }
 
 pplx::task<web::json::value> mitk::RESTClient::Get(const web::uri &uri,
                                                    const utility::string_t &filePath,
                                                    const std::map<utility::string_t, utility::string_t> headers)
 {
-  MITK_INFO << "within client with file path";
+  MITK_DEBUG << "Executing GET with URI: " << mitk::RESTUtil::convertToUtf8(uri.to_string());
   auto client = new http_client(uri);
   auto fileBuffer = std::make_shared<concurrency::streams::streambuf<uint8_t>>();
   http_request request;
 
   for (auto param : headers)
   {
     request.headers().add(param.first, param.second);
   }
 
   // Open file stream for the specified file path
   return file_buffer::open(filePath, std::ios::out)
     .then([=](streambuf outFile) -> pplx::task<http_response> {
       *fileBuffer = outFile;
       return client->request(methods::GET);
     })
     // Write the response body into the file buffer
     .then([=](http_response response) -> pplx::task<size_t> {
       auto status = response.status_code();
 
       if (status_codes::OK != status)
         mitkThrow() << "GET ended up with response " << RESTUtil::convertToUtf8(response.to_string());
       
       return response.body().read_to_end(*fileBuffer);
     })
     // Close the file buffer
     .then([=](size_t) {
       return fileBuffer->close();
     })
     // Return empty JSON object
     .then([=]() {
        return web::json::value();
     });
 }
 
 pplx::task<web::json::value> mitk::RESTClient::Put(const web::uri &uri, const web::json::value *content)
 {
   auto client = new http_client(uri);
   http_request request(methods::PUT);
 
   if (nullptr != content)
     request.set_body(*content);
  
   return client->request(request).then([=](pplx::task<http_response> responseTask) {
     try
     {
       auto response = responseTask.get();
       auto status = response.status_code();
 
       if (status_codes::OK != status)
         mitkThrow();
 
       // Parse content type to application/json if it isn't already. This is
       // important if the content type is e.g. application/dicom+json.
       auto requestContentType = response.headers().content_type();
 
       if (_XPLATSTR("application/json") != requestContentType)
         response.headers().set_content_type(_XPLATSTR("application/json"));
 
       return response.extract_json().get();
     }
     catch (...)
     {
       mitkThrow() << "Getting response went wrong";
     }
   });
 }
 
 pplx::task<web::json::value> mitk::RESTClient::Post(const web::uri &uri, const web::json::value *content)
 {
   auto client = new http_client(uri);
   http_request request(methods::POST);
 
   if (nullptr != content)
     request.set_body(*content);
 
   return client->request(request).then([=](pplx::task<http_response> responseTask) {
     try
     {
       auto response = responseTask.get();
       auto status = response.status_code();
 
       if (status_codes::Created != status)
         mitkThrow();
 
       // Parse content type to application/json if it isn't already. This is
       // important if the content type is e.g. application/dicom+json.
       auto requestContentType = response.headers().content_type();
       if (_XPLATSTR("application/json") != requestContentType)
         response.headers().set_content_type(_XPLATSTR("application/json"));
 
       return response.extract_json().get();
     }
     catch(...)
     {
       mitkThrow() << "Getting response went wrong";
     }
   });
 }
diff --git a/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/DICOMweb.cpp b/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/DICOMweb.cpp
index 2f3e491a2f..0b04ec1fba 100644
--- a/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/DICOMweb.cpp
+++ b/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/DICOMweb.cpp
@@ -1,203 +1,203 @@
 /*===================================================================
 
 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 "DICOMweb.h"
 
 DICOMweb::DICOMweb() {}
 
 DICOMweb::DICOMweb(utility::string_t baseURI) : m_BaseURI(baseURI) {
   MITK_INFO << "base uri: " << mitk::RESTUtil::convertToUtf8(m_BaseURI);
 }
 
 utility::string_t DICOMweb::CreateQIDOUri(mitk::RESTUtil::ParamMap map)
 {
-  MitkUriBuilder queryBuilder(m_BaseURI.append(U("rs/instances")));
+  MitkUriBuilder queryBuilder(m_BaseURI + U("rs/instances"));
 
   for (auto const &element : map)
   {
     queryBuilder.append_query(element.first, element.second);
   }
 
   return queryBuilder.to_string();
 }
 
 /**
   * @brief Creates a WADO request URI with the given parameter
   */
 utility::string_t DICOMweb::CreateWADOUri(utility::string_t studyUID,
                                         utility::string_t seriesUID,
                                         utility::string_t instanceUID)
 {
-  MitkUriBuilder builder(m_BaseURI.append(U("wado")));
+  MitkUriBuilder builder(m_BaseURI + U("wado"));
   builder.append_query(U("requestType"), U("WADO"));
   builder.append_query(U("studyUID"), studyUID);
   builder.append_query(U("seriesUID"), seriesUID);
   builder.append_query(U("objectUID"), instanceUID);
   builder.append_query(U("contentType"), U("application/dicom"));
 
   return builder.to_string();
 }
 
 /**
   * @brief Creates a STOW request URI with the given parameter map
   */
 utility::string_t DICOMweb::CreateSTOWUri(utility::string_t studyUID)
 {
-  MitkUriBuilder builder(m_BaseURI.append(U("rs/studies")));
+  MitkUriBuilder builder(m_BaseURI + U("rs/studies"));
   builder.append_path(studyUID);
   return builder.to_string();
 }
 
 pplx::task<void> DICOMweb::SendSTOW(utility::string_t filePath, utility::string_t studyUID)
 {
   auto uri = CreateSTOWUri(studyUID);
   auto manager = RESTManager();
 
   // TODO: complete STOW
   return manager->SendRequest(uri, mitk::IRESTManager::RequestType::Post, {}, {}, filePath)
     .then([=](web::json::value result){});
 }
 
 pplx::task<void> DICOMweb::SendWADO(utility::string_t filePath,
                                   utility::string_t studyUID,
                                   utility::string_t seriesUID,
                                   utility::string_t instanceUID,
                                   mitk::IRESTManager *manager)
 {
   auto uri = CreateWADOUri(studyUID, seriesUID, instanceUID);
 
   // don't want return something
   return manager->SendRequest(uri, mitk::IRESTManager::RequestType::Get, {}, {}, filePath)
     .then([=](web::json::value result){});
 }
 
 pplx::task<std::string> DICOMweb::SendWADO(utility::string_t folderPath,
                                         utility::string_t studyUID,
                                         utility::string_t seriesUID)
 {
   mitk::RESTUtil::ParamMap seriesInstances;
   seriesInstances.insert(mitk::RESTUtil::ParamMap::value_type(U("StudyInstanceUID"), studyUID));
   seriesInstances.insert(mitk::RESTUtil::ParamMap::value_type(U("SeriesInstanceUID"), seriesUID));
 
   auto *manager = RESTManager();
 
   return SendQIDO(seriesInstances).then([=](web::json::value jsonResult) -> pplx::task<std::string> {
     auto jsonListResult = jsonResult;
     auto resultArray = jsonListResult.as_array();
 
     auto firstFileName = std::string();
 
     std::vector<pplx::task<void>> tasks;
 
     for (unsigned short i = 0; i < resultArray.size(); i++)
     {
       try
       {
         auto firstResult = resultArray[i];
         auto sopInstanceUIDKey = firstResult.at(U("00080018"));
         auto sopInstanceObject = sopInstanceUIDKey.as_object();
         auto valueKey = sopInstanceObject.at(U("Value"));
         auto valueArray = valueKey.as_array();
         auto sopInstanceUID = valueArray[0].as_string();
 
         auto fileName = utility::string_t(sopInstanceUID).append(U(".dcm"));
 
         // save first file name as result to load series
         if (i == 0)
         {
           firstFileName = utility::conversions::to_utf8string(fileName);
         }
 
         auto filePath = utility::string_t(folderPath).append(fileName);
         auto task = SendWADO(filePath, studyUID, seriesUID, sopInstanceUID, manager);
         tasks.push_back(task);
       }
       catch (const web::json::json_exception &e)
       {
         MITK_ERROR << e.what();
       }
     }
 
     auto joinTask = pplx::when_all(begin(tasks), end(tasks));
 
     auto returnTask = joinTask.then([=](void) -> std::string {
       auto folderPathUtf8 = utility::conversions::to_utf8string(folderPath);
       auto result = folderPathUtf8 + firstFileName;
 
       return result;
     });
 
     return returnTask;
   });
 }
 
 pplx::task<web::json::value> DICOMweb::SendQIDO(mitk::RESTUtil::ParamMap map)
 {
   auto uri = CreateQIDOUri(map);
 
   mitk::IRESTManager *manager = RESTManager();
 
   mitk::RESTUtil::ParamMap headers;
   headers.insert(mitk::RESTUtil::ParamMap::value_type(U("Accept"), U("application/json")));
 
   return manager->SendRequest(uri, mitk::IRESTManager::RequestType::Get, {}, headers);
   // return manager->SendRequest(queryBuilder.to_string()).then([=](pplx::task<MitkResponse> taskResponse) {
   //  try
   //  {
   //    MitkResponse response = taskResponse.get();
   //    auto status = response.status_code();
   //    MITK_INFO << " status: " << status;
 
   //    if (status != web::http::status_codes::OK)
   //    {
   //      MITK_ERROR << "no dicom series found for query "
   //                 << utility::conversions::to_utf8string(queryBuilder.to_string());
   //      mitkThrow() << "no dicom series found for query "
   //                  << utility::conversions::to_utf8string(queryBuilder.to_string());
   //    }
 
   //    if (response.headers()[U("Content-Type")] == U("application/dicom+json"))
   //    {
   //      response.headers().remove(U("Content-Type"));
   //      response.headers().add(U("Content-Type"), U("application/json"));
   //    }
 
   //    return response.extract_json().get();
   //  }
   //  catch (std::exception &e)
   //  {
   //    mitkThrow() << e.what();
   //  }
   //});
 }
 
 mitk::IRESTManager* DICOMweb::RESTManager()
 {
   auto *context = us::GetModuleContext();
   auto managerRef = context->GetServiceReference<mitk::IRESTManager>();
   if (managerRef)
   {
     auto managerService = context->GetService(managerRef);
     if (managerService)
     {
       return managerService;
     }
   }
   return nullptr;
 }