diff --git a/hpx/runtime/serialization/container.hpp b/hpx/runtime/serialization/container.hpp
index 96bdb6940f49..674fda1bb6d0 100644
--- a/hpx/runtime/serialization/container.hpp
+++ b/hpx/runtime/serialization/container.hpp
@@ -31,7 +31,7 @@ namespace hpx { namespace serialization
             naming::gid_type const & split_gid) = 0;
         virtual void set_filter(binary_filter* filter) = 0;
         virtual void save_binary(void const* address, std::size_t count) = 0;
-        virtual void save_binary_chunk(void const* address, std::size_t count) = 0;
+        virtual std::size_t save_binary_chunk(void const* address, std::size_t count) = 0;
         virtual void reset() = 0;
         virtual std::size_t get_num_chunks() const = 0;
         virtual void flush() = 0;
diff --git a/hpx/runtime/serialization/output_archive.hpp b/hpx/runtime/serialization/output_archive.hpp
index 313706705999..71a56c8748fb 100644
--- a/hpx/runtime/serialization/output_archive.hpp
+++ b/hpx/runtime/serialization/output_archive.hpp
@@ -197,6 +197,7 @@ namespace hpx { namespace serialization
 
     private:
         friend struct basic_archive<output_archive>;
+
         template <class T>
         friend class array;
 
@@ -357,11 +358,14 @@ namespace hpx { namespace serialization
         void save_binary_chunk(void const * address, std::size_t count)
         {
             if(count == 0) return;
-            size_ += count;
-            if (disable_data_chunking())
+            if (disable_data_chunking()) {
+                size_ += count;
                 buffer_->save_binary(address, count);
-            else
-                buffer_->save_binary_chunk(address, count);
+            }
+            else {
+                // the size might grow if optimizations are not used
+                size_ += buffer_->save_binary_chunk(address, count);
+            }
         }
 
         typedef std::map<const void *, std::uint64_t> pointer_tracker;
diff --git a/hpx/runtime/serialization/output_container.hpp b/hpx/runtime/serialization/output_container.hpp
index 0cef7146d8e0..15bc47e11d0e 100644
--- a/hpx/runtime/serialization/output_container.hpp
+++ b/hpx/runtime/serialization/output_container.hpp
@@ -315,12 +315,14 @@ namespace hpx { namespace serialization
             current_ = new_current;
         }
 
-        void save_binary_chunk(void const* address, std::size_t count) // override
+        std::size_t save_binary_chunk(void const* address, std::size_t count) // override
         {
             if (count < HPX_ZERO_COPY_SERIALIZATION_THRESHOLD)
             {
                 // fall back to serialization_chunk-less archive
                 this->output_container::save_binary(address, count);
+                // the container has grown by count bytes
+                return count;
             }
             else {
                 HPX_ASSERT(
@@ -339,6 +341,8 @@ namespace hpx { namespace serialization
                 // add a new serialization_chunk referring to the external
                 // buffer
                 chunker_.push_back(create_pointer_chunk(address, count));
+                // the container did not grow
+                return 0;
             }
         }
 
@@ -408,7 +412,7 @@ namespace hpx { namespace serialization
             this->current_ += count;
         }
 
-        void save_binary_chunk(void const* address, std::size_t count) // override
+        std::size_t save_binary_chunk(void const* address, std::size_t count) // override
         {
             if (count < HPX_ZERO_COPY_SERIALIZATION_THRESHOLD)
             {
@@ -416,9 +420,10 @@ namespace hpx { namespace serialization
                 HPX_ASSERT(count != 0);
                 filter_->save(address, count);
                 this->current_ += count;
+                return count;
             }
             else {
-                this->base_type::save_binary_chunk(address, count);
+                return this->base_type::save_binary_chunk(address, count);
             }
         }