diff --git a/quic/platform/api/quic_mem_slice_storage.h b/quic/platform/api/quic_mem_slice_storage.h
index dc48a43..9164e9a 100644
--- a/quic/platform/api/quic_mem_slice_storage.h
+++ b/quic/platform/api/quic_mem_slice_storage.h
@@ -30,6 +30,8 @@
   // Return a QuicMemSliceSpan form of the storage.
   QuicMemSliceSpan ToSpan() { return impl_.ToSpan(); }
 
+  void Append(QuicMemSlice slice) { impl_.Append(std::move(*slice.impl())); }
+
  private:
   QuicMemSliceStorageImpl impl_;
 };
diff --git a/quic/platform/api/quic_mem_slice_storage_test.cc b/quic/platform/api/quic_mem_slice_storage_test.cc
index d0c2588..a13899d 100644
--- a/quic/platform/api/quic_mem_slice_storage_test.cc
+++ b/quic/platform/api/quic_mem_slice_storage_test.cc
@@ -3,8 +3,10 @@
 // found in the LICENSE file.
 
 #include "net/third_party/quiche/src/quic/platform/api/quic_mem_slice_storage.h"
+
 #include "net/third_party/quiche/src/quic/core/quic_simple_buffer_allocator.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_test_mem_slice_vector.h"
 
 namespace quic {
 namespace test {
@@ -55,6 +57,24 @@
   EXPECT_EQ("bbbb", span.GetData(1));
 }
 
+TEST_F(QuicMemSliceStorageImplTest, AppendMemSlices) {
+  std::string body1(3, 'a');
+  std::string body2(4, 'b');
+  std::vector<std::pair<char*, size_t>> buffers;
+  buffers.push_back(
+      std::make_pair(const_cast<char*>(body1.data()), body1.length()));
+  buffers.push_back(
+      std::make_pair(const_cast<char*>(body2.data()), body2.length()));
+  QuicTestMemSliceVector mem_slices(buffers);
+
+  QuicMemSliceStorage storage(nullptr, 0, nullptr, 0);
+  mem_slices.span().ConsumeAll(
+      [&storage](QuicMemSlice slice) { storage.Append(std::move(slice)); });
+
+  EXPECT_EQ("aaa", storage.ToSpan().GetData(0));
+  EXPECT_EQ("bbbb", storage.ToSpan().GetData(1));
+}
+
 }  // namespace
 }  // namespace test
 }  // namespace quic
diff --git a/quic/quartc/quartc_session.cc b/quic/quartc/quartc_session.cc
index d23662f..8a918ca 100644
--- a/quic/quartc/quartc_session.cc
+++ b/quic/quartc/quartc_session.cc
@@ -58,9 +58,12 @@
 
   // There may be other messages in send queue, so we have to add message
   // to the queue and call queue processing helper.
-  message.ConsumeAll([this, datagram_id](QuicMemSlice slice) {
-    send_message_queue_.emplace_back(std::move(slice), datagram_id);
+  QueuedMessage queued_message;
+  queued_message.datagram_id = datagram_id;
+  message.ConsumeAll([&queued_message](QuicMemSlice slice) {
+    queued_message.message.Append(std::move(slice));
   });
+  send_message_queue_.push_back(std::move(queued_message));
 
   ProcessSendMessageQueue();
 
@@ -71,8 +74,9 @@
   QuicConnection::ScopedPacketFlusher flusher(connection());
   while (!send_message_queue_.empty()) {
     QueuedMessage& it = send_message_queue_.front();
-    const size_t message_size = it.message.length();
-    MessageResult result = SendMessage(QuicMemSliceSpan(&it.message));
+    QuicMemSliceSpan span = it.message.ToSpan();
+    const size_t message_size = span.total_length();
+    MessageResult result = SendMessage(span);
 
     // Handle errors.
     switch (result.status) {
diff --git a/quic/quartc/quartc_session.h b/quic/quartc/quartc_session.h
index 6828f69..638333e 100644
--- a/quic/quartc/quartc_session.h
+++ b/quic/quartc/quartc_session.h
@@ -15,6 +15,7 @@
 #include "net/third_party/quiche/src/quic/core/quic_session.h"
 #include "net/third_party/quiche/src/quic/core/quic_types.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_containers.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_mem_slice_storage.h"
 #include "net/third_party/quiche/src/quic/quartc/quartc_packet_writer.h"
 #include "net/third_party/quiche/src/quic/quartc/quartc_stream.h"
 
@@ -212,9 +213,9 @@
 
   // Holds message until it's sent.
   struct QueuedMessage {
-    QueuedMessage(QuicMemSlice the_message, int64_t the_datagram_id)
-        : message(std::move(the_message)), datagram_id(the_datagram_id) {}
-    QuicMemSlice message;
+    QueuedMessage() : message(nullptr, 0, nullptr, 0), datagram_id(0) {}
+
+    QuicMemSliceStorage message;
     int64_t datagram_id;
   };
 
diff --git a/quic/quartc/quartc_session_test.cc b/quic/quartc/quartc_session_test.cc
index 8bb9ad1..3b55314 100644
--- a/quic/quartc/quartc_session_test.cc
+++ b/quic/quartc/quartc_session_test.cc
@@ -351,6 +351,28 @@
   TestSendReceiveQueuedMessages(/*direction_from_server=*/false);
 }
 
+TEST_F(QuartcSessionTest, SendMultiMemSliceMessage) {
+  CreateClientAndServerSessions(QuartcSessionConfig());
+  AwaitHandshake();
+  ASSERT_TRUE(server_peer_->CanSendMessage());
+
+  std::vector<std::pair<char*, size_t>> buffers;
+  char first_piece[] = "Hello, ";
+  char second_piece[] = "world!";
+  buffers.emplace_back(first_piece, 7);
+  buffers.emplace_back(second_piece, 6);
+  test::QuicTestMemSliceVector message(buffers);
+  ASSERT_TRUE(
+      server_peer_->SendOrQueueMessage(message.span(), /*datagram_id=*/1));
+
+  // Wait for the client to receive the message.
+  RunTasks();
+
+  // The message is not fragmented along MemSlice boundaries.
+  EXPECT_THAT(client_session_delegate_->incoming_messages(),
+              testing::ElementsAre("Hello, world!"));
+}
+
 TEST_F(QuartcSessionTest, SendMessageFails) {
   CreateClientAndServerSessions(QuartcSessionConfig());
   AwaitHandshake();