diff --git a/libminifi/include/controllers/NetworkPrioritizerService.h b/libminifi/include/controllers/NetworkPrioritizerService.h
index bf7916f..7821f26 100644
--- a/libminifi/include/controllers/NetworkPrioritizerService.h
+++ b/libminifi/include/controllers/NetworkPrioritizerService.h
@@ -89,7 +89,7 @@
 
   virtual void onEnable();
 
-  virtual io::NetworkInterface &&getInterface(uint32_t size);
+  virtual io::NetworkInterface getInterface(uint32_t size);
 
  protected:
 
diff --git a/libminifi/include/io/NetworkPrioritizer.h b/libminifi/include/io/NetworkPrioritizer.h
index 7265f49..6c1f27f 100644
--- a/libminifi/include/io/NetworkPrioritizer.h
+++ b/libminifi/include/io/NetworkPrioritizer.h
@@ -35,7 +35,7 @@
   virtual ~NetworkPrioritizer() {
   }
 
-  virtual NetworkInterface &&getInterface(uint32_t size) = 0;
+  virtual NetworkInterface getInterface(uint32_t size) = 0;
 
  protected:
   friend class NetworkInterface;
@@ -46,15 +46,21 @@
 class NetworkInterface {
  public:
 
-  NetworkInterface() : prioritizer_(nullptr){
+  NetworkInterface()
+      : prioritizer_(nullptr) {
   }
 
-  virtual ~NetworkInterface(){
+  virtual ~NetworkInterface() {
   }
 
   explicit NetworkInterface(const std::string &ifc, const std::shared_ptr<NetworkPrioritizer> &prioritizer)
-      : ifc_(ifc),
-        prioritizer_(prioritizer) {
+      : prioritizer_(prioritizer) {
+    ifc_ = ifc;
+  }
+
+  NetworkInterface(const NetworkInterface &other)
+      : prioritizer_(other.prioritizer_) {
+    ifc_ = other.ifc_;
   }
 
   explicit NetworkInterface(const NetworkInterface &&other)
@@ -90,6 +96,10 @@
 
 class NetworkPrioritizerFactory {
  public:
+  NetworkPrioritizerFactory()
+      : np_(nullptr) {
+
+  }
   static std::shared_ptr<NetworkPrioritizerFactory> getInstance() {
     static std::shared_ptr<NetworkPrioritizerFactory> fa = std::make_shared<NetworkPrioritizerFactory>();
     return fa;
diff --git a/libminifi/include/io/StreamFactory.h b/libminifi/include/io/StreamFactory.h
index f3fc95e..6f71434 100644
--- a/libminifi/include/io/StreamFactory.h
+++ b/libminifi/include/io/StreamFactory.h
@@ -55,7 +55,6 @@
     auto socket = delegate_->createSocket(host, port);
     auto prioritizer_ = NetworkPrioritizerFactory::getInstance()->getPrioritizer();
     if (nullptr != prioritizer_) {
-      std::cout << "prioritizer" << std::endl;
       auto &&ifc = prioritizer_->getInterface(estimated_size);
       if (ifc.getInterface().empty()) {
         return nullptr;
diff --git a/libminifi/src/controllers/NetworkPrioritizerService.cpp b/libminifi/src/controllers/NetworkPrioritizerService.cpp
index d88921b..63210ec 100644
--- a/libminifi/src/controllers/NetworkPrioritizerService.cpp
+++ b/libminifi/src/controllers/NetworkPrioritizerService.cpp
@@ -65,8 +65,9 @@
 /**
  * If not an intersecting operation we will attempt to locate the highest priority interface available.
  */
-io::NetworkInterface &&NetworkPrioritizerService::getInterface(uint32_t size = 0) {
+io::NetworkInterface NetworkPrioritizerService::getInterface(uint32_t size = 0) {
   std::vector<std::string> controllers;
+  std::string ifc = "";
   if (!network_controllers_.empty()) {
     if (sufficient_tokens(size) && size < max_payload_) {
       controllers.insert(std::end(controllers), std::begin(network_controllers_), std::end(network_controllers_));
@@ -74,24 +75,28 @@
   }
 
   if (!controllers.empty()) {
-    auto ifc = get_nearest_interface(controllers);
+    ifc = get_nearest_interface(controllers);
     if (!ifc.empty()) {
       reduce_tokens(size);
-      return std::move(io::NetworkInterface(ifc, shared_from_this()));
+      io::NetworkInterface newifc(ifc, shared_from_this());
+      return newifc;
     }
   }
   for (size_t i = 0; i < linked_services_.size(); i++) {
     auto np = std::dynamic_pointer_cast<NetworkPrioritizerService>(linked_services_.at(i));
     if (np != nullptr) {
       auto ifcs = np->getInterfaces(size);
-      auto ifc = get_nearest_interface(ifcs);
+      ifc = get_nearest_interface(ifcs);
       if (!ifc.empty()) {
         np->reduce_tokens(size);
-        return std::move(io::NetworkInterface(ifc, np));
+        io::NetworkInterface newifc(ifc, np);
+        return newifc;
       }
     }
   }
-  return std::move(io::NetworkInterface("", nullptr));
+
+  io::NetworkInterface newifc(ifc, nullptr);
+  return newifc;
 }
 
 std::string NetworkPrioritizerService::get_nearest_interface(const std::vector<std::string> &ifcs) {