diff --git a/build/source_list.bzl b/build/source_list.bzl
index 9ab0ba3..110f0da 100644
--- a/build/source_list.bzl
+++ b/build/source_list.bzl
@@ -307,7 +307,6 @@
     "quic/core/quic_interval.h",
     "quic/core/quic_interval_deque.h",
     "quic/core/quic_interval_set.h",
-    "quic/core/quic_legacy_version_encapsulator.h",
     "quic/core/quic_lru_cache.h",
     "quic/core/quic_mtu_discovery.h",
     "quic/core/quic_network_blackhole_detector.h",
@@ -636,7 +635,6 @@
     "quic/core/quic_flow_controller.cc",
     "quic/core/quic_framer.cc",
     "quic/core/quic_idle_network_detector.cc",
-    "quic/core/quic_legacy_version_encapsulator.cc",
     "quic/core/quic_mtu_discovery.cc",
     "quic/core/quic_network_blackhole_detector.cc",
     "quic/core/quic_packet_creator.cc",
@@ -1205,7 +1203,6 @@
     "quic/core/quic_interval_deque_test.cc",
     "quic/core/quic_interval_set_test.cc",
     "quic/core/quic_interval_test.cc",
-    "quic/core/quic_legacy_version_encapsulator_test.cc",
     "quic/core/quic_lru_cache_test.cc",
     "quic/core/quic_network_blackhole_detector_test.cc",
     "quic/core/quic_one_block_arena_test.cc",
diff --git a/build/source_list.gni b/build/source_list.gni
index 35107f0..94401df 100644
--- a/build/source_list.gni
+++ b/build/source_list.gni
@@ -307,7 +307,6 @@
     "src/quiche/quic/core/quic_interval.h",
     "src/quiche/quic/core/quic_interval_deque.h",
     "src/quiche/quic/core/quic_interval_set.h",
-    "src/quiche/quic/core/quic_legacy_version_encapsulator.h",
     "src/quiche/quic/core/quic_lru_cache.h",
     "src/quiche/quic/core/quic_mtu_discovery.h",
     "src/quiche/quic/core/quic_network_blackhole_detector.h",
@@ -636,7 +635,6 @@
     "src/quiche/quic/core/quic_flow_controller.cc",
     "src/quiche/quic/core/quic_framer.cc",
     "src/quiche/quic/core/quic_idle_network_detector.cc",
-    "src/quiche/quic/core/quic_legacy_version_encapsulator.cc",
     "src/quiche/quic/core/quic_mtu_discovery.cc",
     "src/quiche/quic/core/quic_network_blackhole_detector.cc",
     "src/quiche/quic/core/quic_packet_creator.cc",
@@ -1205,7 +1203,6 @@
     "src/quiche/quic/core/quic_interval_deque_test.cc",
     "src/quiche/quic/core/quic_interval_set_test.cc",
     "src/quiche/quic/core/quic_interval_test.cc",
-    "src/quiche/quic/core/quic_legacy_version_encapsulator_test.cc",
     "src/quiche/quic/core/quic_lru_cache_test.cc",
     "src/quiche/quic/core/quic_network_blackhole_detector_test.cc",
     "src/quiche/quic/core/quic_one_block_arena_test.cc",
diff --git a/build/source_list.json b/build/source_list.json
index a4394c8..599ccdd 100644
--- a/build/source_list.json
+++ b/build/source_list.json
@@ -306,7 +306,6 @@
     "quiche/quic/core/quic_interval.h",
     "quiche/quic/core/quic_interval_deque.h",
     "quiche/quic/core/quic_interval_set.h",
-    "quiche/quic/core/quic_legacy_version_encapsulator.h",
     "quiche/quic/core/quic_lru_cache.h",
     "quiche/quic/core/quic_mtu_discovery.h",
     "quiche/quic/core/quic_network_blackhole_detector.h",
@@ -635,7 +634,6 @@
     "quiche/quic/core/quic_flow_controller.cc",
     "quiche/quic/core/quic_framer.cc",
     "quiche/quic/core/quic_idle_network_detector.cc",
-    "quiche/quic/core/quic_legacy_version_encapsulator.cc",
     "quiche/quic/core/quic_mtu_discovery.cc",
     "quiche/quic/core/quic_network_blackhole_detector.cc",
     "quiche/quic/core/quic_packet_creator.cc",
@@ -1204,7 +1202,6 @@
     "quiche/quic/core/quic_interval_deque_test.cc",
     "quiche/quic/core/quic_interval_set_test.cc",
     "quiche/quic/core/quic_interval_test.cc",
-    "quiche/quic/core/quic_legacy_version_encapsulator_test.cc",
     "quiche/quic/core/quic_lru_cache_test.cc",
     "quiche/quic/core/quic_network_blackhole_detector_test.cc",
     "quiche/quic/core/quic_one_block_arena_test.cc",
diff --git a/quiche/quic/core/crypto/crypto_protocol.h b/quiche/quic/core/crypto/crypto_protocol.h
index 7cfffd9..e64f3c8 100644
--- a/quiche/quic/core/crypto/crypto_protocol.h
+++ b/quiche/quic/core/crypto/crypto_protocol.h
@@ -31,7 +31,7 @@
 // "QNZR", "B2HI", "H2PR", "FIFO", "LIFO", "RRWS", "QNSP", "B2CL", "CHSP",
 // "BPTE", "ACKD", "AKD2", "AKD4", "MAD1", "MAD4", "MAD5", "ACD0", "ACKQ",
 // "TLPR", "CCS\0", "PDP4", "NCHP", "NBPE", "2RTO", "3RTO", "4RTO", "6RTO",
-// "PDP1", "PDP2", "PDP3", "PDP5"
+// "PDP1", "PDP2", "PDP3", "PDP5" "QLVE"
 
 // clang-format off
 const QuicTag kCHLO = TAG('C', 'H', 'L', 'O');   // Client hello
@@ -395,8 +395,6 @@
                                                  // flow control receive window.
 const QuicTag kUAID = TAG('U', 'A', 'I', 'D');   // Client's User Agent ID.
 const QuicTag kXLCT = TAG('X', 'L', 'C', 'T');   // Expected leaf certificate.
-const QuicTag kQLVE = TAG('Q', 'L', 'V', 'E');   // Legacy Version
-                                                 // Encapsulation.
 
 const QuicTag kQNZ2 = TAG('Q', 'N', 'Z', '2');   // Turn off QUIC crypto 0-RTT.
 
diff --git a/quiche/quic/core/http/end_to_end_test.cc b/quiche/quic/core/http/end_to_end_test.cc
index af39239..3fc79a9 100644
--- a/quiche/quic/core/http/end_to_end_test.cc
+++ b/quiche/quic/core/http/end_to_end_test.cc
@@ -6056,109 +6056,6 @@
   server_thread_->Resume();
 }
 
-TEST_P(EndToEndTest, LegacyVersionEncapsulation) {
-  if (GetQuicRestartFlag(quic_disable_legacy_version_encapsulation)) {
-    ASSERT_TRUE(Initialize());
-    return;
-  }
-  if (!version_.HasLongHeaderLengths() ||
-      override_server_connection_id_length_ > -1) {
-    // Decapsulating Legacy Version Encapsulation packets from these versions
-    // is not currently supported in QuicDispatcher.
-    ASSERT_TRUE(Initialize());
-    return;
-  }
-  client_config_.SetClientConnectionOptions(QuicTagVector{kQLVE});
-  ASSERT_TRUE(Initialize());
-  SendSynchronousFooRequestAndCheckResponse();
-  QuicConnection* client_connection = GetClientConnection();
-  ASSERT_TRUE(client_connection);
-  EXPECT_GT(
-      client_connection->GetStats().sent_legacy_version_encapsulated_packets,
-      0u);
-}
-
-TEST_P(EndToEndTest, LegacyVersionEncapsulationWithMultiPacketChlo) {
-  if (GetQuicRestartFlag(quic_disable_legacy_version_encapsulation)) {
-    ASSERT_TRUE(Initialize());
-    return;
-  }
-  if (!version_.HasLongHeaderLengths() ||
-      override_server_connection_id_length_ > -1) {
-    // Decapsulating Legacy Version Encapsulation packets from these versions
-    // is not currently supported in QuicDispatcher.
-    ASSERT_TRUE(Initialize());
-    return;
-  }
-  if (!version_.UsesTls()) {
-    // This test uses custom transport parameters to increase the size of the
-    // CHLO, and those are only supported with TLS.
-    ASSERT_TRUE(Initialize());
-    return;
-  }
-  client_config_.SetClientConnectionOptions(QuicTagVector{kQLVE});
-  constexpr auto kCustomParameter =
-      static_cast<TransportParameters::TransportParameterId>(0xff34);
-  client_config_.custom_transport_parameters_to_send()[kCustomParameter] =
-      std::string(2000, '?');
-  ASSERT_TRUE(Initialize());
-  SendSynchronousFooRequestAndCheckResponse();
-  QuicConnection* client_connection = GetClientConnection();
-  ASSERT_TRUE(client_connection);
-  EXPECT_GT(
-      client_connection->GetStats().sent_legacy_version_encapsulated_packets,
-      0u);
-}
-
-TEST_P(EndToEndTest, LegacyVersionEncapsulationWithVersionNegotiation) {
-  if (GetQuicRestartFlag(quic_disable_legacy_version_encapsulation)) {
-    ASSERT_TRUE(Initialize());
-    return;
-  }
-  if (!version_.HasLongHeaderLengths() ||
-      override_server_connection_id_length_ > -1) {
-    // Decapsulating Legacy Version Encapsulation packets from these versions
-    // is not currently supported in QuicDispatcher.
-    ASSERT_TRUE(Initialize());
-    return;
-  }
-  client_supported_versions_.insert(client_supported_versions_.begin(),
-                                    QuicVersionReservedForNegotiation());
-  client_config_.SetClientConnectionOptions(QuicTagVector{kQLVE});
-  ASSERT_TRUE(Initialize());
-  SendSynchronousFooRequestAndCheckResponse();
-  QuicConnection* client_connection = GetClientConnection();
-  ASSERT_TRUE(client_connection);
-  EXPECT_GT(
-      client_connection->GetStats().sent_legacy_version_encapsulated_packets,
-      0u);
-}
-
-TEST_P(EndToEndTest, LegacyVersionEncapsulationWithLoss) {
-  if (GetQuicRestartFlag(quic_disable_legacy_version_encapsulation)) {
-    ASSERT_TRUE(Initialize());
-    return;
-  }
-  if (!version_.HasLongHeaderLengths() ||
-      override_server_connection_id_length_ > -1) {
-    // Decapsulating Legacy Version Encapsulation packets from these versions
-    // is not currently supported in QuicDispatcher.
-    ASSERT_TRUE(Initialize());
-    return;
-  }
-  SetPacketLossPercentage(30);
-  client_config_.SetClientConnectionOptions(QuicTagVector{kQLVE});
-  // Disable blackhole detection as this test is testing loss recovery.
-  client_extra_copts_.push_back(kNBHD);
-  ASSERT_TRUE(Initialize());
-  SendSynchronousFooRequestAndCheckResponse();
-  QuicConnection* client_connection = GetClientConnection();
-  ASSERT_TRUE(client_connection);
-  EXPECT_GT(
-      client_connection->GetStats().sent_legacy_version_encapsulated_packets,
-      0u);
-}
-
 // Testing packet writer that makes a copy of the first sent packets before
 // sending them. Useful for tests that need access to sent packets.
 class CopyingPacketWriter : public PacketDroppingTestWriter {
diff --git a/quiche/quic/core/http/quic_spdy_client_session.cc b/quiche/quic/core/http/quic_spdy_client_session.cc
index 707281a..12bb511 100644
--- a/quiche/quic/core/http/quic_spdy_client_session.cc
+++ b/quiche/quic/core/http/quic_spdy_client_session.cc
@@ -36,14 +36,6 @@
 
 void QuicSpdyClientSession::Initialize() {
   crypto_stream_ = CreateQuicCryptoStream();
-  if (config()->HasClientRequestedIndependentOption(kQLVE,
-                                                    Perspective::IS_CLIENT)) {
-    if (GetQuicRestartFlag(quic_disable_legacy_version_encapsulation)) {
-      QUIC_CODE_COUNT(quic_disable_legacy_version_encapsulation_client_init);
-    } else {
-      connection()->EnableLegacyVersionEncapsulation(server_id_.host());
-    }
-  }
   QuicSpdyClientSessionBase::Initialize();
 }
 
diff --git a/quiche/quic/core/quic_connection.cc b/quiche/quic/core/quic_connection.cc
index 0e71a7f..5c44172 100644
--- a/quiche/quic/core/quic_connection.cc
+++ b/quiche/quic/core/quic_connection.cc
@@ -32,7 +32,6 @@
 #include "quiche/quic/core/quic_connection_id.h"
 #include "quiche/quic/core/quic_constants.h"
 #include "quiche/quic/core/quic_error_codes.h"
-#include "quiche/quic/core/quic_legacy_version_encapsulator.h"
 #include "quiche/quic/core/quic_packet_creator.h"
 #include "quiche/quic/core/quic_packet_writer.h"
 #include "quiche/quic/core/quic_packets.h"
@@ -675,7 +674,8 @@
       GetQuicReloadableFlag(quic_connection_migration_use_new_cid_v2);
   if (config.HasReceivedMaxPacketSize()) {
     peer_max_packet_size_ = config.ReceivedMaxPacketSize();
-    MaybeUpdatePacketCreatorMaxPacketLengthAndPadding();
+    packet_creator_.SetMaxPacketLength(
+        GetLimitedMaxPacketSize(packet_creator_.max_packet_length()));
   }
   if (config.HasReceivedMaxDatagramFrameSize()) {
     packet_creator_.SetMaxDatagramFrameSize(
@@ -698,31 +698,6 @@
   }
 }
 
-void QuicConnection::EnableLegacyVersionEncapsulation(
-    const std::string& server_name) {
-  if (perspective_ != Perspective::IS_CLIENT) {
-    QUIC_BUG(quic_bug_10511_1)
-        << "Cannot enable Legacy Version Encapsulation on the server";
-    return;
-  }
-  if (legacy_version_encapsulation_enabled_) {
-    QUIC_BUG(quic_bug_10511_2)
-        << "Do not call EnableLegacyVersionEncapsulation twice";
-    return;
-  }
-  if (!QuicHostnameUtils::IsValidSNI(server_name)) {
-    // Legacy Version Encapsulation is only used when SNI is transmitted.
-    QUIC_DLOG(INFO)
-        << "Refusing to use Legacy Version Encapsulation with invalid SNI \""
-        << server_name << "\"";
-    return;
-  }
-  QUIC_DLOG(INFO) << "Enabling Legacy Version Encapsulation with SNI \""
-                  << server_name << "\"";
-  legacy_version_encapsulation_enabled_ = true;
-  legacy_version_encapsulation_sni_ = server_name;
-}
-
 bool QuicConnection::MaybeTestLiveness() {
   QUICHE_DCHECK_EQ(perspective_, Perspective::IS_CLIENT);
   if (encryption_level_ != ENCRYPTION_FORWARD_SECURE) {
@@ -2441,29 +2416,6 @@
   }
 }
 
-void QuicConnection::MaybeActivateLegacyVersionEncapsulation() {
-  if (!legacy_version_encapsulation_enabled_) {
-    return;
-  }
-  QUICHE_DCHECK(!legacy_version_encapsulation_in_progress_);
-  QUIC_BUG_IF(quic_bug_12714_19, !packet_creator_.CanSetMaxPacketLength())
-      << "Cannot activate Legacy Version Encapsulation mid-packet";
-  QUIC_BUG_IF(quic_bug_12714_20, coalesced_packet_.length() != 0u)
-      << "Cannot activate Legacy Version Encapsulation mid-coalesced-packet";
-  legacy_version_encapsulation_in_progress_ = true;
-  MaybeUpdatePacketCreatorMaxPacketLengthAndPadding();
-}
-void QuicConnection::MaybeDisactivateLegacyVersionEncapsulation() {
-  if (!legacy_version_encapsulation_in_progress_) {
-    return;
-  }
-  // Flush any remaining packet before disactivating encapsulation.
-  packet_creator_.FlushCurrentPacket();
-  QUICHE_DCHECK(legacy_version_encapsulation_enabled_);
-  legacy_version_encapsulation_in_progress_ = false;
-  MaybeUpdatePacketCreatorMaxPacketLengthAndPadding();
-}
-
 size_t QuicConnection::SendCryptoData(EncryptionLevel level,
                                       size_t write_length,
                                       QuicStreamOffset offset) {
@@ -2471,17 +2423,8 @@
     QUIC_BUG(quic_bug_10511_18) << "Attempt to send empty crypto frame";
     return 0;
   }
-  if (level == ENCRYPTION_INITIAL) {
-    MaybeActivateLegacyVersionEncapsulation();
-  }
-  size_t consumed_length;
-  {
-    ScopedPacketFlusher flusher(this);
-    consumed_length =
-        packet_creator_.ConsumeCryptoData(level, write_length, offset);
-  }  // Added scope ensures packets are flushed before continuing.
-  MaybeDisactivateLegacyVersionEncapsulation();
-  return consumed_length;
+  ScopedPacketFlusher flusher(this);
+  return packet_creator_.ConsumeCryptoData(level, write_length, offset);
 }
 
 QuicConsumedData QuicConnection::SendStreamData(QuicStreamId id,
@@ -2493,10 +2436,6 @@
     return QuicConsumedData(0, false);
   }
 
-  if (packet_creator_.encryption_level() == ENCRYPTION_INITIAL &&
-      QuicUtils::IsCryptoStreamId(transport_version(), id)) {
-    MaybeActivateLegacyVersionEncapsulation();
-  }
   if (perspective_ == Perspective::IS_SERVER &&
       version().CanSendCoalescedPackets() && !IsHandshakeConfirmed()) {
     if (in_on_retransmission_time_out_ &&
@@ -2514,20 +2453,14 @@
       sent_packet_manager_.RetransmitDataOfSpaceIfAny(HANDSHAKE_DATA);
     }
   }
-  QuicConsumedData consumed_data(0, false);
-  {
-    // Opportunistically bundle an ack with every outgoing packet.
-    // Particularly, we want to bundle with handshake packets since we don't
-    // know which decrypter will be used on an ack packet following a handshake
-    // packet (a handshake packet from client to server could result in a REJ or
-    // a SHLO from the server, leading to two different decrypters at the
-    // server.)
-    ScopedPacketFlusher flusher(this);
-    consumed_data =
-        packet_creator_.ConsumeData(id, write_length, offset, state);
-  }  // Added scope ensures packets are flushed before continuing.
-  MaybeDisactivateLegacyVersionEncapsulation();
-  return consumed_data;
+  // Opportunistically bundle an ack with every outgoing packet.
+  // Particularly, we want to bundle with handshake packets since we don't
+  // know which decrypter will be used on an ack packet following a handshake
+  // packet (a handshake packet from client to server could result in a REJ or
+  // a SHLO from the server, leading to two different decrypters at the
+  // server.)
+  ScopedPacketFlusher flusher(this);
+  return packet_creator_.ConsumeData(id, write_length, offset, state);
 }
 
 bool QuicConnection::SendControlFrame(const QuicFrame& frame) {
@@ -2707,28 +2640,6 @@
   return info;
 }
 
-void QuicConnection::MaybeUpdatePacketCreatorMaxPacketLengthAndPadding() {
-  QuicByteCount max_packet_length = GetLimitedMaxPacketSize(long_term_mtu_);
-  if (legacy_version_encapsulation_in_progress_) {
-    QUICHE_DCHECK(legacy_version_encapsulation_enabled_);
-    const QuicByteCount minimum_overhead =
-        QuicLegacyVersionEncapsulator::GetMinimumOverhead(
-            legacy_version_encapsulation_sni_);
-    if (max_packet_length < minimum_overhead) {
-      QUIC_BUG(quic_bug_10511_20)
-          << "Cannot apply Legacy Version Encapsulation overhead because "
-          << "max_packet_length " << max_packet_length << " < minimum_overhead "
-          << minimum_overhead;
-      legacy_version_encapsulation_in_progress_ = false;
-      legacy_version_encapsulation_enabled_ = false;
-      MaybeUpdatePacketCreatorMaxPacketLengthAndPadding();
-      return;
-    }
-    max_packet_length -= minimum_overhead;
-  }
-  packet_creator_.SetMaxPacketLength(max_packet_length);
-}
-
 void QuicConnection::ProcessUdpPacket(const QuicSocketAddress& self_address,
                                       const QuicSocketAddress& peer_address,
                                       const QuicReceivedPacket& packet) {
@@ -3488,49 +3399,6 @@
         result = writer_->Flush();
       }
       break;
-    case LEGACY_VERSION_ENCAPSULATE: {
-      QUICHE_DCHECK(!is_mtu_discovery);
-      QUICHE_DCHECK_EQ(perspective_, Perspective::IS_CLIENT);
-      QUICHE_DCHECK_EQ(packet->encryption_level, ENCRYPTION_INITIAL);
-      QUICHE_DCHECK(legacy_version_encapsulation_enabled_);
-      QUICHE_DCHECK(legacy_version_encapsulation_in_progress_);
-      QuicPacketLength encapsulated_length =
-          QuicLegacyVersionEncapsulator::Encapsulate(
-              legacy_version_encapsulation_sni_,
-              absl::string_view(packet->encrypted_buffer,
-                                packet->encrypted_length),
-              default_path_.server_connection_id, framer_.creation_time(),
-              GetLimitedMaxPacketSize(long_term_mtu_),
-              const_cast<char*>(packet->encrypted_buffer));
-      if (encapsulated_length != 0) {
-        stats_.sent_legacy_version_encapsulated_packets++;
-        packet->encrypted_length = encapsulated_length;
-        encrypted_length = encapsulated_length;
-        QUIC_DVLOG(2)
-            << ENDPOINT
-            << "Successfully performed Legacy Version Encapsulation on "
-            << packet->encryption_level << " packet number " << packet_number
-            << " of length " << encrypted_length << ": " << std::endl
-            << quiche::QuicheTextUtils::HexDump(absl::string_view(
-                   packet->encrypted_buffer, encrypted_length));
-      } else {
-        QUIC_BUG(quic_bug_10511_24)
-            << ENDPOINT << "Failed to perform Legacy Version Encapsulation on "
-            << packet->encryption_level << " packet number " << packet_number
-            << " of length " << encrypted_length;
-      }
-      if (!buffered_packets_.empty() || HandleWriteBlocked()) {
-        // Buffer the packet.
-        buffered_packets_.emplace_back(*packet, self_address(),
-                                       send_to_address);
-      } else {  // Send the packet to the writer.
-        // writer_->WritePacket transfers buffer ownership back to the writer.
-        packet->release_encrypted_buffer = nullptr;
-        result = writer_->WritePacket(packet->encrypted_buffer,
-                                      encrypted_length, self_address().host(),
-                                      send_to_address, per_packet_options_);
-      }
-    } break;
     default:
       QUICHE_DCHECK(false);
       break;
@@ -4673,7 +4541,7 @@
 void QuicConnection::SetMaxPacketLength(QuicByteCount length) {
   long_term_mtu_ = length;
   stats_.max_egress_mtu = std::max(stats_.max_egress_mtu, long_term_mtu_);
-  MaybeUpdatePacketCreatorMaxPacketLengthAndPadding();
+  packet_creator_.SetMaxPacketLength(GetLimitedMaxPacketSize(length));
 }
 
 bool QuicConnection::HasQueuedData() const {
@@ -6162,10 +6030,6 @@
   if (ShouldDiscardPacket(encryption_level)) {
     return DISCARD;
   }
-  if (legacy_version_encapsulation_in_progress_) {
-    QUICHE_DCHECK(!is_mtu_discovery);
-    return LEGACY_VERSION_ENCAPSULATE;
-  }
   if (version().CanSendCoalescedPackets() && !coalescing_done_ &&
       !is_mtu_discovery) {
     if (!IsHandshakeConfirmed()) {
diff --git a/quiche/quic/core/quic_connection.h b/quiche/quic/core/quic_connection.h
index 578de98..36e9bbf 100644
--- a/quiche/quic/core/quic_connection.h
+++ b/quiche/quic/core/quic_connection.h
@@ -1167,10 +1167,6 @@
 
   virtual void OnUserAgentIdKnown(const std::string& user_agent_id);
 
-  // Enables Legacy Version Encapsulation using |server_name| as SNI.
-  // Can only be set if this is a client connection.
-  void EnableLegacyVersionEncapsulation(const std::string& server_name);
-
   // If now is close to idle timeout, returns true and sends a connectivity
   // probing packet to test the connection for liveness. Otherwise, returns
   // false.
@@ -1822,13 +1818,6 @@
   // Returns string which contains undecryptable packets information.
   std::string UndecryptablePacketsInfo() const;
 
-  // Sets the max packet length on the packet creator if needed.
-  void MaybeUpdatePacketCreatorMaxPacketLengthAndPadding();
-
-  // Sets internal state to enable or disable Legacy Version Encapsulation.
-  void MaybeActivateLegacyVersionEncapsulation();
-  void MaybeDisactivateLegacyVersionEncapsulation();
-
   // For Google Quic, if the current packet is connectivity probing packet, call
   // session OnPacketReceived() which eventually sends connectivity probing
   // response on server side. And no-op on client side. And for both Google Quic
@@ -2223,13 +2212,6 @@
   const bool default_enable_5rto_blackhole_detection_ =
       GetQuicReloadableFlag(quic_default_enable_5rto_blackhole_detection2);
 
-  // Whether the Legacy Version Encapsulation feature is enabled.
-  bool legacy_version_encapsulation_enabled_ = false;
-  // Whether we are in the middle of sending a packet using Legacy Version
-  // Encapsulation.
-  bool legacy_version_encapsulation_in_progress_ = false;
-  // SNI to send when using Legacy Version Encapsulation.
-  std::string legacy_version_encapsulation_sni_;
   // True if next packet is intended to consume remaining space in the
   // coalescer.
   bool fill_coalesced_packet_ = false;
diff --git a/quiche/quic/core/quic_connection_stats.cc b/quiche/quic/core/quic_connection_stats.cc
index 105d957..b5561eb 100644
--- a/quiche/quic/core/quic_connection_stats.cc
+++ b/quiche/quic/core/quic_connection_stats.cc
@@ -55,8 +55,6 @@
   os << " num_coalesced_packets_processed: "
      << s.num_coalesced_packets_processed;
   os << " num_ack_aggregation_epochs: " << s.num_ack_aggregation_epochs;
-  os << " sent_legacy_version_encapsulated_packets: "
-     << s.sent_legacy_version_encapsulated_packets;
   os << " key_update_count: " << s.key_update_count;
   os << " num_failed_authentication_packets_received: "
      << s.num_failed_authentication_packets_received;
diff --git a/quiche/quic/core/quic_connection_stats.h b/quiche/quic/core/quic_connection_stats.h
index 2d25495..bf21073 100644
--- a/quiche/quic/core/quic_connection_stats.h
+++ b/quiche/quic/core/quic_connection_stats.h
@@ -170,10 +170,6 @@
   // Max consecutive retransmission timeout before making forward progress.
   size_t max_consecutive_rto_with_forward_progress = 0;
 
-  // Number of sent packets that were encapsulated using Legacy Version
-  // Encapsulation.
-  QuicPacketCount sent_legacy_version_encapsulated_packets = 0;
-
   // Number of times when the connection tries to send data but gets throttled
   // by amplification factor.
   size_t num_amplification_throttling = 0;
diff --git a/quiche/quic/core/quic_connection_test.cc b/quiche/quic/core/quic_connection_test.cc
index 608d306..ee2a090 100644
--- a/quiche/quic/core/quic_connection_test.cc
+++ b/quiche/quic/core/quic_connection_test.cc
@@ -9994,49 +9994,6 @@
   EXPECT_QUIC_BUG(test_body(), "SerializeCoalescedPacket failed.");
 }
 
-TEST_P(QuicConnectionTest, LegacyVersionEncapsulation) {
-  connection_.EnableLegacyVersionEncapsulation("test.example.org");
-
-  MockQuicConnectionDebugVisitor debug_visitor;
-  connection_.set_debug_visitor(&debug_visitor);
-  EXPECT_CALL(debug_visitor, OnPacketSent(_, _, _, _, _, _, _, _)).Times(1);
-
-  // Our TestPacketWriter normally parses the sent packet using the version
-  // from the connection, so here we need to tell it to use the encapsulation
-  // version, and reset the initial decrypter for that version.
-  writer_->framer()->SetSupportedVersions(
-      SupportedVersions(LegacyVersionForEncapsulation()));
-  writer_->framer()->framer()->SetInitialObfuscators(
-      connection_.connection_id());
-
-  {
-    QuicConnection::ScopedPacketFlusher flusher(&connection_);
-    connection_.SendCryptoDataWithString("TEST_CRYPTO_DATA", /*offset=*/0);
-  }
-
-  EXPECT_EQ(1u, writer_->packets_write_attempts());
-  // Verify that the packet is fully padded.
-  EXPECT_EQ(connection_.max_packet_length(), writer_->last_packet_size());
-
-  // Check that the connection stats show Legacy Version Encapsulation was used.
-  EXPECT_GT(connection_.GetStats().sent_legacy_version_encapsulated_packets,
-            0u);
-
-  // Verify that the sent packet was in fact encapsulated, and check header.
-  const QuicPacketHeader& encapsulated_header = writer_->last_packet_header();
-  EXPECT_TRUE(encapsulated_header.version_flag);
-  EXPECT_EQ(encapsulated_header.version, LegacyVersionForEncapsulation());
-  EXPECT_EQ(encapsulated_header.destination_connection_id,
-            connection_.connection_id());
-
-  // Encapsulated packet should contain a stream frame for the crypto stream,
-  // optionally padding, and nothing else.
-  EXPECT_EQ(0u, writer_->crypto_frames().size());
-  EXPECT_EQ(1u, writer_->stream_frames().size());
-  EXPECT_EQ(writer_->frame_count(), writer_->framer()->padding_frames().size() +
-                                        writer_->stream_frames().size());
-}
-
 TEST_P(QuicConnectionTest, ClientReceivedHandshakeDone) {
   if (!connection_.version().UsesTls()) {
     return;
diff --git a/quiche/quic/core/quic_dispatcher.cc b/quiche/quic/core/quic_dispatcher.cc
index 63fa567..e82ddce 100644
--- a/quiche/quic/core/quic_dispatcher.cc
+++ b/quiche/quic/core/quic_dispatcher.cc
@@ -212,7 +212,7 @@
 // Class which extracts the ALPN and SNI from a QUIC_CRYPTO CHLO packet.
 class ChloAlpnSniExtractor : public ChloExtractor::Delegate {
  public:
-  void OnChlo(QuicTransportVersion version,
+  void OnChlo(QuicTransportVersion /*version*/,
               QuicConnectionId /*server_connection_id*/,
               const CryptoHandshakeMessage& chlo) override {
     absl::string_view alpn_value;
@@ -227,12 +227,6 @@
     if (chlo.GetStringPiece(quic::kUAID, &uaid_value)) {
       uaid_ = std::string(uaid_value);
     }
-    if (version == LegacyVersionForEncapsulation().transport_version) {
-      absl::string_view qlve_value;
-      if (chlo.GetStringPiece(kQLVE, &qlve_value)) {
-        legacy_version_encapsulation_inner_packet_ = std::string(qlve_value);
-      }
-    }
   }
 
   std::string&& ConsumeAlpn() { return std::move(alpn_); }
@@ -241,91 +235,12 @@
 
   std::string&& ConsumeUaid() { return std::move(uaid_); }
 
-  std::string&& ConsumeLegacyVersionEncapsulationInnerPacket() {
-    return std::move(legacy_version_encapsulation_inner_packet_);
-  }
-
  private:
   std::string alpn_;
   std::string sni_;
   std::string uaid_;
-  std::string legacy_version_encapsulation_inner_packet_;
 };
 
-bool MaybeHandleLegacyVersionEncapsulation(
-    QuicDispatcher* dispatcher,
-    std::string legacy_version_encapsulation_inner_packet,
-    const ReceivedPacketInfo& packet_info) {
-  QUICHE_DCHECK(!GetQuicRestartFlag(quic_disable_legacy_version_encapsulation));
-  if (legacy_version_encapsulation_inner_packet.empty()) {
-    // This CHLO did not contain the Legacy Version Encapsulation tag.
-    return false;
-  }
-  PacketHeaderFormat format;
-  QuicLongHeaderType long_packet_type;
-  bool version_present;
-  bool has_length_prefix;
-  QuicVersionLabel version_label;
-  ParsedQuicVersion parsed_version = ParsedQuicVersion::Unsupported();
-  QuicConnectionId destination_connection_id, source_connection_id;
-  absl::optional<absl::string_view> retry_token;
-  std::string detailed_error;
-  const QuicErrorCode error = QuicFramer::ParsePublicHeaderDispatcher(
-      QuicEncryptedPacket(legacy_version_encapsulation_inner_packet.data(),
-                          legacy_version_encapsulation_inner_packet.length()),
-      kQuicDefaultConnectionIdLength, &format, &long_packet_type,
-      &version_present, &has_length_prefix, &version_label, &parsed_version,
-      &destination_connection_id, &source_connection_id, &retry_token,
-      &detailed_error);
-  if (error != QUIC_NO_ERROR) {
-    QUIC_DLOG(ERROR)
-        << "Failed to parse Legacy Version Encapsulation inner packet:"
-        << detailed_error;
-    return false;
-  }
-  if (destination_connection_id != packet_info.destination_connection_id) {
-    // We enforce that the inner and outer connection IDs match to make sure
-    // this never impacts routing of packets.
-    QUIC_DLOG(ERROR) << "Ignoring Legacy Version Encapsulation packet "
-                        "with mismatched connection ID "
-                     << destination_connection_id << " vs "
-                     << packet_info.destination_connection_id;
-    return false;
-  }
-  if (legacy_version_encapsulation_inner_packet.length() >=
-      packet_info.packet.length()) {
-    QUIC_BUG(quic_bug_10287_2)
-        << "Inner packet cannot be larger than outer "
-        << legacy_version_encapsulation_inner_packet.length() << " vs "
-        << packet_info.packet.length();
-    return false;
-  }
-
-  QUIC_DVLOG(1) << "Extracted a Legacy Version Encapsulation "
-                << legacy_version_encapsulation_inner_packet.length()
-                << " byte packet of version " << parsed_version;
-
-  // Append zeroes to the end of the packet. This will ensure that
-  // we use the right number of bytes for calculating anti-amplification
-  // limits. Note that this only works for long headers of versions that carry
-  // long header lengths, since they'll ignore any trailing zeroes. We still
-  // do this for all packets to ensure version negotiation works.
-  legacy_version_encapsulation_inner_packet.append(
-      packet_info.packet.length() -
-          legacy_version_encapsulation_inner_packet.length(),
-      0x00);
-
-  // Process the inner packet as if it had been received by itself.
-  QuicReceivedPacket received_encapsulated_packet(
-      legacy_version_encapsulation_inner_packet.data(),
-      legacy_version_encapsulation_inner_packet.length(),
-      packet_info.packet.receipt_time());
-  dispatcher->ProcessPacket(packet_info.self_address, packet_info.peer_address,
-                            received_encapsulated_packet);
-  QUIC_CODE_COUNT(quic_legacy_version_encapsulation_decapsulated);
-  return true;
-}
-
 }  // namespace
 
 QuicDispatcher::QuicDispatcher(
@@ -594,29 +509,6 @@
   auto it = reference_counted_session_map_.find(server_connection_id);
   if (it != reference_counted_session_map_.end()) {
     QUICHE_DCHECK(!buffered_packets_.HasBufferedPackets(server_connection_id));
-    if (packet_info.version_flag &&
-        packet_info.version != it->second->version() &&
-        packet_info.version == LegacyVersionForEncapsulation()) {
-      // This packet is using the Legacy Version Encapsulation version but the
-      // corresponding session isn't, attempt extraction of inner packet.
-      if (GetQuicRestartFlag(quic_disable_legacy_version_encapsulation)) {
-        QUIC_CODE_COUNT(
-            quic_disable_legacy_version_encapsulation_dispatch_packet);
-      } else {
-        ChloAlpnSniExtractor alpn_extractor;
-        if (ChloExtractor::Extract(packet_info.packet, packet_info.version,
-                                   config_->create_session_tag_indicators(),
-                                   &alpn_extractor,
-                                   server_connection_id.length())) {
-          if (MaybeHandleLegacyVersionEncapsulation(
-                  this,
-                  alpn_extractor.ConsumeLegacyVersionEncapsulationInnerPacket(),
-                  packet_info)) {
-            return true;
-          }
-        }
-      }
-    }
     it->second->ProcessUdpPacket(packet_info.self_address,
                                  packet_info.peer_address, packet_info.packet);
     return true;
@@ -740,22 +632,6 @@
       fate = ValidityChecksOnFullChlo(*packet_info, *parsed_chlo);
 
       if (fate == kFateProcess) {
-        QUICHE_DCHECK(
-            parsed_chlo->legacy_version_encapsulation_inner_packet.empty() ||
-            !packet_info->version.UsesTls());
-        if (GetQuicRestartFlag(quic_disable_legacy_version_encapsulation)) {
-          if (!parsed_chlo->legacy_version_encapsulation_inner_packet.empty()) {
-            QUIC_CODE_COUNT(
-                quic_disable_legacy_version_encapsulation_process_header);
-          }
-        } else {
-          if (MaybeHandleLegacyVersionEncapsulation(
-                  this, parsed_chlo->legacy_version_encapsulation_inner_packet,
-                  *packet_info)) {
-            return;
-          }
-        }
-
         ProcessChlo(*std::move(parsed_chlo), packet_info);
         return;
       }
@@ -882,8 +758,6 @@
   }
 
   ParsedClientHello& parsed_chlo = result.parsed_chlo.emplace();
-  parsed_chlo.legacy_version_encapsulation_inner_packet =
-      alpn_extractor.ConsumeLegacyVersionEncapsulationInnerPacket();
   parsed_chlo.sni = alpn_extractor.ConsumeSni();
   parsed_chlo.uaid = alpn_extractor.ConsumeUaid();
   parsed_chlo.alpns = {alpn_extractor.ConsumeAlpn()};
diff --git a/quiche/quic/core/quic_dispatcher_test.cc b/quiche/quic/core/quic_dispatcher_test.cc
index 0447586..ed5ea0c 100644
--- a/quiche/quic/core/quic_dispatcher_test.cc
+++ b/quiche/quic/core/quic_dispatcher_test.cc
@@ -677,73 +677,6 @@
                                 /*long_connection_id=*/true);
 }
 
-TEST_P(QuicDispatcherTestAllVersions, LegacyVersionEncapsulation) {
-  if (GetQuicRestartFlag(quic_disable_legacy_version_encapsulation)) {
-    return;
-  }
-  if (!version_.HasLongHeaderLengths()) {
-    // Decapsulating Legacy Version Encapsulation packets from these versions
-    // is not currently supported in QuicDispatcher.
-    return;
-  }
-  QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
-  QuicConnectionId server_connection_id = TestConnectionId();
-  QuicConfig client_config = DefaultQuicConfig();
-  client_config.SetClientConnectionOptions(QuicTagVector{kQLVE});
-  std::vector<std::unique_ptr<QuicReceivedPacket>> packets =
-      GetFirstFlightOfPackets(version_, client_config, server_connection_id);
-  ASSERT_EQ(packets.size(), 1u);
-
-  // Validate that Legacy Version Encapsulation is actually being used by
-  // checking the version of the packet before processing it.
-  PacketHeaderFormat format = IETF_QUIC_LONG_HEADER_PACKET;
-  QuicLongHeaderType long_packet_type;
-  bool version_present;
-  bool has_length_prefix;
-  QuicVersionLabel version_label;
-  ParsedQuicVersion parsed_version = ParsedQuicVersion::Unsupported();
-  QuicConnectionId destination_connection_id, source_connection_id;
-  absl::optional<absl::string_view> retry_token;
-  std::string detailed_error;
-  const QuicErrorCode error = QuicFramer::ParsePublicHeaderDispatcher(
-      QuicEncryptedPacket(packets[0]->data(), packets[0]->length()),
-      kQuicDefaultConnectionIdLength, &format, &long_packet_type,
-      &version_present, &has_length_prefix, &version_label, &parsed_version,
-      &destination_connection_id, &source_connection_id, &retry_token,
-      &detailed_error);
-  ASSERT_THAT(error, IsQuicNoError()) << detailed_error;
-  EXPECT_EQ(format, GOOGLE_QUIC_PACKET);
-  EXPECT_TRUE(version_present);
-  EXPECT_FALSE(has_length_prefix);
-  EXPECT_EQ(parsed_version, LegacyVersionForEncapsulation());
-  EXPECT_EQ(destination_connection_id, server_connection_id);
-  EXPECT_EQ(source_connection_id, EmptyQuicConnectionId());
-  EXPECT_FALSE(retry_token.has_value());
-  EXPECT_TRUE(detailed_error.empty());
-
-  // Processing the packet should create a new session.
-  EXPECT_CALL(*dispatcher_,
-              CreateQuicSession(server_connection_id, _, client_address,
-                                Eq(ExpectedAlpn()), _, _))
-      .WillOnce(Return(ByMove(CreateSession(
-          dispatcher_.get(), config_, server_connection_id, client_address,
-          &mock_helper_, &mock_alarm_factory_, &crypto_config_,
-          QuicDispatcherPeer::GetCache(dispatcher_.get()), &session1_))));
-  EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
-              ProcessUdpPacket(_, _, _))
-      .Times(2);
-
-  ProcessReceivedPacket(packets[0]->Clone(), client_address, version_,
-                        server_connection_id);
-  EXPECT_EQ(dispatcher_->NumSessions(), 1u);
-
-  // Processing the same packet a second time should also be routed by the
-  // dispatcher to the right connection (we expect ProcessUdpPacket to be
-  // called twice, see the EXPECT_CALL above).
-  ProcessReceivedPacket(std::move(packets[0]), client_address, version_,
-                        server_connection_id);
-}
-
 TEST_P(QuicDispatcherTestAllVersions, ProcessPackets) {
   QuicSocketAddress client_address(QuicIpAddress::Loopback4(), 1);
 
diff --git a/quiche/quic/core/quic_flags_list.h b/quiche/quic/core/quic_flags_list.h
index d8e8cd8..20f5594 100644
--- a/quiche/quic/core/quic_flags_list.h
+++ b/quiche/quic/core/quic_flags_list.h
@@ -19,8 +19,6 @@
 QUIC_FLAG(quic_restart_flag_quic_testonly_default_true, true)
 // If trrue, early return before write control frame in OnCanWrite() if the connection is already closed.
 QUIC_FLAG(quic_reloadable_flag_quic_no_write_control_frame_upon_connection_close, true)
-// If true, QUIC Legacy Version Encapsulation will be disabled.
-QUIC_FLAG(quic_restart_flag_quic_disable_legacy_version_encapsulation, true)
 // If true, QUIC will default enable MTU discovery at server, with a target of 1450 bytes.
 QUIC_FLAG(quic_reloadable_flag_quic_enable_mtu_discovery_at_server, false)
 // If true, QuicConnectionContext will track the decrypted payload and the offset of the current frame, for debugging.
diff --git a/quiche/quic/core/quic_legacy_version_encapsulator.cc b/quiche/quic/core/quic_legacy_version_encapsulator.cc
deleted file mode 100644
index d2c6082..0000000
--- a/quiche/quic/core/quic_legacy_version_encapsulator.cc
+++ /dev/null
@@ -1,148 +0,0 @@
-// Copyright (c) 2020 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "quiche/quic/core/quic_legacy_version_encapsulator.h"
-
-#include "quiche/quic/core/crypto/crypto_handshake_message.h"
-#include "quiche/quic/core/crypto/crypto_protocol.h"
-#include "quiche/quic/core/quic_utils.h"
-#include "quiche/quic/platform/api/quic_bug_tracker.h"
-
-namespace quic {
-
-QuicLegacyVersionEncapsulator::QuicLegacyVersionEncapsulator(
-    QuicPacketBuffer packet_buffer)
-    : packet_buffer_(packet_buffer) {}
-
-QuicLegacyVersionEncapsulator::~QuicLegacyVersionEncapsulator() {}
-
-// static
-QuicByteCount QuicLegacyVersionEncapsulator::GetMinimumOverhead(
-    absl::string_view sni) {
-  // The number 52 is the sum of:
-  // - Flags (1 byte)
-  // - Server Connection ID (8 bytes)
-  // - Version (4 bytes)
-  // - Packet Number (1 byte)
-  // - Message Authentication Hash (12 bytes)
-  // - Frame Type (1 byte)
-  // - Stream ID (1 byte)
-  // - ClientHello tag (4 bytes)
-  // - ClientHello num tags (2 bytes)
-  // - Padding (2 bytes)
-  // - SNI tag (4 bytes)
-  // - SNI end offset (4 bytes)
-  // - QLVE tag (4 bytes)
-  // - QLVE end offset (4 bytes)
-  return 52 + sni.length();
-}
-
-QuicPacketBuffer QuicLegacyVersionEncapsulator::GetPacketBuffer() {
-  return packet_buffer_;
-}
-
-void QuicLegacyVersionEncapsulator::OnSerializedPacket(
-    SerializedPacket serialized_packet) {
-  if (encrypted_length_ != 0) {
-    unrecoverable_failure_encountered_ = true;
-    QUIC_BUG(quic_bug_10615_1) << "OnSerializedPacket called twice";
-    return;
-  }
-  if (serialized_packet.encrypted_length == 0) {
-    unrecoverable_failure_encountered_ = true;
-    QUIC_BUG(quic_bug_10615_2) << "OnSerializedPacket called with empty packet";
-    return;
-  }
-  encrypted_length_ = serialized_packet.encrypted_length;
-}
-
-void QuicLegacyVersionEncapsulator::OnUnrecoverableError(
-    QuicErrorCode error, const std::string& error_details) {
-  unrecoverable_failure_encountered_ = true;
-  QUIC_BUG(quic_bug_10615_3) << "QuicLegacyVersionEncapsulator received error "
-                             << error << ": " << error_details;
-}
-
-bool QuicLegacyVersionEncapsulator::ShouldGeneratePacket(
-    HasRetransmittableData /*retransmittable*/, IsHandshake /*handshake*/) {
-  return true;
-}
-
-const QuicFrames
-QuicLegacyVersionEncapsulator::MaybeBundleAckOpportunistically() {
-  // We do not want to ever include any ACKs here, return an empty array.
-  return QuicFrames();
-}
-
-SerializedPacketFate QuicLegacyVersionEncapsulator::GetSerializedPacketFate(
-    bool /*is_mtu_discovery*/, EncryptionLevel /*encryption_level*/) {
-  return SEND_TO_WRITER;
-}
-
-// static
-QuicPacketLength QuicLegacyVersionEncapsulator::Encapsulate(
-    absl::string_view sni, absl::string_view inner_packet,
-    const QuicConnectionId& server_connection_id, QuicTime creation_time,
-    QuicByteCount outer_max_packet_length, char* out) {
-  if (outer_max_packet_length > kMaxOutgoingPacketSize) {
-    outer_max_packet_length = kMaxOutgoingPacketSize;
-  }
-  CryptoHandshakeMessage outer_chlo;
-  outer_chlo.set_tag(kCHLO);
-  outer_chlo.SetStringPiece(kSNI, sni);
-  outer_chlo.SetStringPiece(kQLVE, inner_packet);
-  const QuicData& serialized_outer_chlo = outer_chlo.GetSerialized();
-  QUICHE_DCHECK(!LegacyVersionForEncapsulation().UsesCryptoFrames());
-  QUICHE_DCHECK(LegacyVersionForEncapsulation().UsesQuicCrypto());
-  QuicStreamFrame outer_stream_frame(
-      QuicUtils::GetCryptoStreamId(
-          LegacyVersionForEncapsulation().transport_version),
-      /*fin=*/false,
-      /*offset=*/0, serialized_outer_chlo.AsStringPiece());
-  QuicFramer outer_framer(
-      ParsedQuicVersionVector{LegacyVersionForEncapsulation()}, creation_time,
-      Perspective::IS_CLIENT, kQuicDefaultConnectionIdLength);
-  outer_framer.SetInitialObfuscators(server_connection_id);
-  char outer_encrypted_packet[kMaxOutgoingPacketSize];
-  QuicPacketBuffer outer_packet_buffer(outer_encrypted_packet, nullptr);
-  QuicLegacyVersionEncapsulator creator_delegate(outer_packet_buffer);
-  QuicPacketCreator outer_creator(server_connection_id, &outer_framer,
-                                  &creator_delegate);
-  outer_creator.SetMaxPacketLength(outer_max_packet_length);
-  outer_creator.set_encryption_level(ENCRYPTION_INITIAL);
-  outer_creator.SetTransmissionType(NOT_RETRANSMISSION);
-  if (!outer_creator.AddPaddedSavedFrame(QuicFrame(outer_stream_frame),
-                                         NOT_RETRANSMISSION)) {
-    QUIC_BUG(quic_bug_10615_4)
-        << "Failed to add Legacy Version Encapsulation stream frame "
-           "(max packet length is "
-        << outer_creator.max_packet_length() << ") " << outer_stream_frame;
-    return 0;
-  }
-  outer_creator.FlushCurrentPacket();
-  const QuicPacketLength encrypted_length = creator_delegate.encrypted_length_;
-  if (creator_delegate.unrecoverable_failure_encountered_ ||
-      encrypted_length == 0) {
-    QUIC_BUG(quic_bug_10615_5)
-        << "Failed to perform Legacy Version Encapsulation of "
-        << inner_packet.length() << " bytes";
-    return 0;
-  }
-  if (encrypted_length > kMaxOutgoingPacketSize) {
-    QUIC_BUG(quic_bug_10615_6)
-        << "Legacy Version Encapsulation outer creator generated a "
-           "packet with unexpected length "
-        << encrypted_length;
-    return 0;
-  }
-
-  QUIC_DLOG(INFO) << "Successfully performed Legacy Version Encapsulation from "
-                  << inner_packet.length() << " bytes to " << encrypted_length;
-
-  // Replace our current packet with the encapsulated one.
-  memcpy(out, outer_encrypted_packet, encrypted_length);
-  return encrypted_length;
-}
-
-}  // namespace quic
diff --git a/quiche/quic/core/quic_legacy_version_encapsulator.h b/quiche/quic/core/quic_legacy_version_encapsulator.h
deleted file mode 100644
index bc96725..0000000
--- a/quiche/quic/core/quic_legacy_version_encapsulator.h
+++ /dev/null
@@ -1,70 +0,0 @@
-// Copyright (c) 2020 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef QUICHE_QUIC_CORE_QUIC_LEGACY_VERSION_ENCAPSULATOR_H_
-#define QUICHE_QUIC_CORE_QUIC_LEGACY_VERSION_ENCAPSULATOR_H_
-
-#include "absl/strings/string_view.h"
-#include "quiche/quic/core/quic_packet_creator.h"
-#include "quiche/quic/core/quic_packets.h"
-#include "quiche/quic/core/quic_types.h"
-#include "quiche/quic/platform/api/quic_export.h"
-
-namespace quic {
-
-// QuicLegacyVersionEncapsulator is responsible for encapsulation of packets
-// using Legacy Version Encapsulation.
-
-class QUIC_EXPORT_PRIVATE QuicLegacyVersionEncapsulator
-    : public QuicPacketCreator::DelegateInterface {
- public:
-  // Encapsulates |inner_packet| into a new encapsulated packet that uses a
-  // CHLO of version LegacyVersionForEncapsulation() with server name |sni|
-  // exposed and using |server_connection_id|. The packet will be padded up to
-  // |outer_max_packet_length| bytes if necessary. On failure, returns 0. On
-  // success, returns the length of the outer encapsulated packet, and copies
-  // the contents of the encapsulated packet to |out|. |out| must point to a
-  // valid memory buffer capable of holding kMaxOutgoingPacketSize bytes.
-  static QuicPacketLength Encapsulate(
-      absl::string_view sni, absl::string_view inner_packet,
-      const QuicConnectionId& server_connection_id, QuicTime creation_time,
-      QuicByteCount outer_max_packet_length, char* out);
-
-  // Returns the number of bytes of minimum overhead caused by Legacy Version
-  // Encapsulation, based on the length of the provided server name |sni|.
-  // The overhead may be higher due to extra padding added.
-  static QuicByteCount GetMinimumOverhead(absl::string_view sni);
-
-  // Overrides for QuicPacketCreator::DelegateInterface.
-  QuicPacketBuffer GetPacketBuffer() override;
-  void OnSerializedPacket(SerializedPacket serialized_packet) override;
-  void OnUnrecoverableError(QuicErrorCode error,
-                            const std::string& error_details) override;
-  bool ShouldGeneratePacket(HasRetransmittableData retransmittable,
-                            IsHandshake handshake) override;
-  const QuicFrames MaybeBundleAckOpportunistically() override;
-  SerializedPacketFate GetSerializedPacketFate(
-      bool is_mtu_discovery, EncryptionLevel encryption_level) override;
-
-  ~QuicLegacyVersionEncapsulator() override;
-
- private:
-  explicit QuicLegacyVersionEncapsulator(QuicPacketBuffer packet_buffer);
-
-  // Disallow copy, move and assignment.
-  QuicLegacyVersionEncapsulator(const QuicLegacyVersionEncapsulator&) = delete;
-  QuicLegacyVersionEncapsulator(QuicLegacyVersionEncapsulator&&) = delete;
-  QuicLegacyVersionEncapsulator& operator=(
-      const QuicLegacyVersionEncapsulator&) = delete;
-  QuicLegacyVersionEncapsulator& operator=(QuicLegacyVersionEncapsulator&&) =
-      delete;
-
-  QuicPacketBuffer packet_buffer_;
-  QuicPacketLength encrypted_length_ = 0;
-  bool unrecoverable_failure_encountered_ = false;
-};
-
-}  // namespace quic
-
-#endif  // QUICHE_QUIC_CORE_QUIC_LEGACY_VERSION_ENCAPSULATOR_H_
diff --git a/quiche/quic/core/quic_legacy_version_encapsulator_test.cc b/quiche/quic/core/quic_legacy_version_encapsulator_test.cc
deleted file mode 100644
index 928386d..0000000
--- a/quiche/quic/core/quic_legacy_version_encapsulator_test.cc
+++ /dev/null
@@ -1,107 +0,0 @@
-// Copyright (c) 2020 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "quiche/quic/core/quic_legacy_version_encapsulator.h"
-
-#include "absl/strings/string_view.h"
-#include "quiche/quic/core/quic_versions.h"
-#include "quiche/quic/platform/api/quic_expect_bug.h"
-#include "quiche/quic/platform/api/quic_test.h"
-#include "quiche/quic/test_tools/quic_test_utils.h"
-
-namespace quic {
-namespace test {
-namespace {
-
-class QuicLegacyVersionEncapsulatorTest
-    : public QuicTestWithParam<ParsedQuicVersion> {
- protected:
-  QuicLegacyVersionEncapsulatorTest()
-      : version_(GetParam()),
-        sni_("test.example.org"),
-        server_connection_id_(TestConnectionId()),
-        outer_max_packet_length_(kMaxOutgoingPacketSize),
-        encapsulated_length_(0) {}
-
-  void Encapsulate(const std::string& inner_packet) {
-    encapsulated_length_ = QuicLegacyVersionEncapsulator::Encapsulate(
-        sni_, inner_packet, server_connection_id_, QuicTime::Zero(),
-        outer_max_packet_length_, outer_buffer_);
-  }
-
-  void CheckEncapsulation() {
-    ASSERT_NE(encapsulated_length_, 0u);
-    ASSERT_EQ(encapsulated_length_, outer_max_packet_length_);
-    // Verify that the encapsulated packet parses as encapsulated.
-    PacketHeaderFormat format = IETF_QUIC_LONG_HEADER_PACKET;
-    QuicLongHeaderType long_packet_type;
-    bool version_present;
-    bool has_length_prefix;
-    QuicVersionLabel version_label;
-    ParsedQuicVersion parsed_version = ParsedQuicVersion::Unsupported();
-    QuicConnectionId destination_connection_id, source_connection_id;
-    absl::optional<absl::string_view> retry_token;
-    std::string detailed_error;
-    const QuicErrorCode error = QuicFramer::ParsePublicHeaderDispatcher(
-        QuicEncryptedPacket(outer_buffer_, encapsulated_length_),
-        kQuicDefaultConnectionIdLength, &format, &long_packet_type,
-        &version_present, &has_length_prefix, &version_label, &parsed_version,
-        &destination_connection_id, &source_connection_id, &retry_token,
-        &detailed_error);
-    ASSERT_THAT(error, IsQuicNoError()) << detailed_error;
-    EXPECT_EQ(format, GOOGLE_QUIC_PACKET);
-    EXPECT_TRUE(version_present);
-    EXPECT_FALSE(has_length_prefix);
-    EXPECT_EQ(parsed_version, LegacyVersionForEncapsulation());
-    EXPECT_EQ(destination_connection_id, server_connection_id_);
-    EXPECT_EQ(source_connection_id, EmptyQuicConnectionId());
-    EXPECT_FALSE(retry_token.has_value());
-    EXPECT_TRUE(detailed_error.empty());
-  }
-
-  QuicByteCount Overhead() {
-    return QuicLegacyVersionEncapsulator::GetMinimumOverhead(sni_);
-  }
-
-  ParsedQuicVersion version_;
-  std::string sni_;
-  QuicConnectionId server_connection_id_;
-  QuicByteCount outer_max_packet_length_;
-  char outer_buffer_[kMaxOutgoingPacketSize];
-  QuicPacketLength encapsulated_length_;
-};
-
-INSTANTIATE_TEST_SUITE_P(QuicLegacyVersionEncapsulatorTests,
-                         QuicLegacyVersionEncapsulatorTest,
-                         ::testing::ValuesIn(AllSupportedVersions()),
-                         ::testing::PrintToStringParamName());
-
-TEST_P(QuicLegacyVersionEncapsulatorTest, Simple) {
-  Encapsulate("TEST_INNER_PACKET");
-  CheckEncapsulation();
-}
-
-TEST_P(QuicLegacyVersionEncapsulatorTest, TooBig) {
-  std::string inner_packet(kMaxOutgoingPacketSize, '?');
-  EXPECT_QUIC_BUG(Encapsulate(inner_packet), "Legacy Version Encapsulation");
-  ASSERT_EQ(encapsulated_length_, 0u);
-}
-
-TEST_P(QuicLegacyVersionEncapsulatorTest, BarelyFits) {
-  QuicByteCount inner_size = kMaxOutgoingPacketSize - Overhead();
-  std::string inner_packet(inner_size, '?');
-  Encapsulate(inner_packet);
-  CheckEncapsulation();
-}
-
-TEST_P(QuicLegacyVersionEncapsulatorTest, DoesNotQuiteFit) {
-  QuicByteCount inner_size = 1 + kMaxOutgoingPacketSize - Overhead();
-  std::string inner_packet(inner_size, '?');
-  EXPECT_QUIC_BUG(Encapsulate(inner_packet), "Legacy Version Encapsulation");
-  ASSERT_EQ(encapsulated_length_, 0u);
-}
-
-}  // namespace
-}  // namespace test
-}  // namespace quic
diff --git a/quiche/quic/core/quic_packet_creator.cc b/quiche/quic/core/quic_packet_creator.cc
index 6f29e52..ad4e785 100644
--- a/quiche/quic/core/quic_packet_creator.cc
+++ b/quiche/quic/core/quic_packet_creator.cc
@@ -1881,9 +1881,8 @@
     return;
   }
 
-  if (packet_.fate == COALESCE || packet_.fate == LEGACY_VERSION_ENCAPSULATE) {
-    // Do not add full padding if the packet is going to be coalesced or
-    // encapsulated.
+  if (packet_.fate == COALESCE) {
+    // Do not add full padding if the packet is going to be coalesced.
     needs_full_padding_ = false;
   }
 
diff --git a/quiche/quic/core/quic_types.cc b/quiche/quic/core/quic_types.cc
index 6e74dd7..46b2fc2 100644
--- a/quiche/quic/core/quic_types.cc
+++ b/quiche/quic/core/quic_types.cc
@@ -297,7 +297,6 @@
     RETURN_STRING_LITERAL(COALESCE);
     RETURN_STRING_LITERAL(BUFFER);
     RETURN_STRING_LITERAL(SEND_TO_WRITER);
-    RETURN_STRING_LITERAL(LEGACY_VERSION_ENCAPSULATE);
   }
   return absl::StrCat("Unknown(", static_cast<int>(fate), ")");
 }
@@ -419,8 +418,6 @@
 
 bool operator==(const ParsedClientHello& a, const ParsedClientHello& b) {
   return a.sni == b.sni && a.uaid == b.uaid && a.alpns == b.alpns &&
-         a.legacy_version_encapsulation_inner_packet ==
-             b.legacy_version_encapsulation_inner_packet &&
          a.retry_token == b.retry_token &&
          a.resumption_attempted == b.resumption_attempted &&
          a.early_data_attempted == b.early_data_attempted;
@@ -430,9 +427,7 @@
                          const ParsedClientHello& parsed_chlo) {
   os << "{ sni:" << parsed_chlo.sni << ", uaid:" << parsed_chlo.uaid
      << ", alpns:" << quiche::PrintElements(parsed_chlo.alpns)
-     << ", len(retry_token):" << parsed_chlo.retry_token.size()
-     << ", len(inner_packet):"
-     << parsed_chlo.legacy_version_encapsulation_inner_packet.size() << " }";
+     << ", len(retry_token):" << parsed_chlo.retry_token.size() << " }";
   return os;
 }
 
diff --git a/quiche/quic/core/quic_types.h b/quiche/quic/core/quic_types.h
index ffaf6c6..1496625 100644
--- a/quiche/quic/core/quic_types.h
+++ b/quiche/quic/core/quic_types.h
@@ -710,8 +710,6 @@
   COALESCE,                    // Try to coalesce packet.
   BUFFER,                      // Buffer packet in buffered_packets_.
   SEND_TO_WRITER,              // Send packet to writer.
-  LEGACY_VERSION_ENCAPSULATE,  // Perform Legacy Version Encapsulation on this
-                               // packet.
 };
 
 QUIC_EXPORT_PRIVATE std::string SerializedPacketFateToString(
@@ -848,7 +846,6 @@
   std::string sni;                 // QUIC crypto and TLS.
   std::string uaid;                // QUIC crypto only.
   std::vector<std::string> alpns;  // QUIC crypto and TLS.
-  std::string legacy_version_encapsulation_inner_packet;  // QUIC crypto only.
   // The unvalidated retry token from the last received packet of a potentially
   // multi-packet client hello. TLS only.
   std::string retry_token;
diff --git a/quiche/quic/core/quic_versions.cc b/quiche/quic/core/quic_versions.cc
index cc9065b..89b58b5 100644
--- a/quiche/quic/core/quic_versions.cc
+++ b/quiche/quic/core/quic_versions.cc
@@ -631,10 +631,6 @@
   return ParsedQuicVersion::ReservedForNegotiation();
 }
 
-ParsedQuicVersion LegacyVersionForEncapsulation() {
-  return ParsedQuicVersion::Q043();
-}
-
 std::string AlpnForVersion(ParsedQuicVersion parsed_version) {
   if (parsed_version == ParsedQuicVersion::V2Draft01()) {
     return "h3";
diff --git a/quiche/quic/core/quic_versions.h b/quiche/quic/core/quic_versions.h
index 39f8642..374db5d 100644
--- a/quiche/quic/core/quic_versions.h
+++ b/quiche/quic/core/quic_versions.h
@@ -383,10 +383,6 @@
 
 QUIC_EXPORT_PRIVATE ParsedQuicVersion QuicVersionReservedForNegotiation();
 
-// Outer version used when encapsulating other packets using the Legacy Version
-// Encapsulation feature.
-QUIC_EXPORT_PRIVATE ParsedQuicVersion LegacyVersionForEncapsulation();
-
 QUIC_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
                                              const ParsedQuicVersion& version);