diff --git a/quic/core/http/quic_spdy_session.cc b/quic/core/http/quic_spdy_session.cc
index e264f3d..701a4c5 100644
--- a/quic/core/http/quic_spdy_session.cc
+++ b/quic/core/http/quic_spdy_session.cc
@@ -380,16 +380,16 @@
             headers_stream_->id());
 
   unowned_headers_stream_ = headers_stream_.get();
-  RegisterStaticStreamNew(std::move(headers_stream_),
-                          /*stream_already_counted = */ false);
+  RegisterStaticStream(std::move(headers_stream_),
+                       /*stream_already_counted = */ false);
 
   if (VersionHasStreamType(connection()->transport_version())) {
     auto send_control = QuicMakeUnique<QuicSendControlStream>(
         GetNextOutgoingUnidirectionalStreamId(), this,
         max_inbound_header_list_size_);
     send_control_stream_ = send_control.get();
-    RegisterStaticStreamNew(std::move(send_control),
-                            /*stream_already_counted = */ false);
+    RegisterStaticStream(std::move(send_control),
+                         /*stream_already_counted = */ false);
   }
 
   set_max_uncompressed_header_bytes(max_inbound_header_list_size_);
@@ -775,8 +775,8 @@
     case kControlStream: {  // HTTP/3 control stream.
       auto receive_stream = QuicMakeUnique<QuicReceiveControlStream>(pending);
       receive_control_stream_ = receive_stream.get();
-      RegisterStaticStreamNew(std::move(receive_stream),
-                              /*stream_already_counted = */ true);
+      RegisterStaticStream(std::move(receive_stream),
+                           /*stream_already_counted = */ true);
       receive_control_stream_->SetUnblocked();
       return true;
     }
diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc
index 8d94beb..5e6cbd4 100644
--- a/quic/core/quic_session.cc
+++ b/quic/core/quic_session.cc
@@ -81,7 +81,6 @@
           perspective() == Perspective::IS_SERVER,
           nullptr),
       currently_writing_stream_id_(0),
-      largest_static_stream_id_(0),
       is_handshake_confirmed_(false),
       goaway_sent_(false),
       goaway_received_(false),
@@ -109,7 +108,6 @@
 
   QuicStreamId id =
       QuicUtils::GetCryptoStreamId(connection_->transport_version());
-  largest_static_stream_id_ = std::max(id, largest_static_stream_id_);
   if (VersionHasIetfQuicFrames(connection_->transport_version())) {
     v99_streamid_manager_.RegisterStaticStream(id, false);
   }
@@ -119,23 +117,8 @@
   QUIC_LOG_IF(WARNING, !zombie_streams_.empty()) << "Still have zombie streams";
 }
 
-void QuicSession::RegisterStaticStream(QuicStreamId id, QuicStream* stream) {
-  static_stream_map_[id] = stream;
-
-  QUIC_BUG_IF(id >
-              largest_static_stream_id_ +
-                  QuicUtils::StreamIdDelta(connection_->transport_version()))
-      << ENDPOINT << "Static stream registered out of order: " << id
-      << " vs: " << largest_static_stream_id_;
-  largest_static_stream_id_ = std::max(id, largest_static_stream_id_);
-
-  if (VersionHasIetfQuicFrames(connection_->transport_version())) {
-    v99_streamid_manager_.RegisterStaticStream(id, false);
-  }
-}
-
-void QuicSession::RegisterStaticStreamNew(std::unique_ptr<QuicStream> stream,
-                                          bool stream_already_counted) {
+void QuicSession::RegisterStaticStream(std::unique_ptr<QuicStream> stream,
+                                       bool stream_already_counted) {
   DCHECK(stream->is_static());
   QuicStreamId stream_id = stream->id();
   dynamic_stream_map_[stream_id] = std::move(stream);
@@ -187,13 +170,6 @@
     return;
   }
 
-  if (frame.fin && QuicContainsKey(static_stream_map_, stream_id)) {
-    connection()->CloseConnection(
-        QUIC_INVALID_STREAM_ID, "Attempt to close a static stream",
-        ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
-    return;
-  }
-
   if (UsesPendingStreams() &&
       QuicUtils::GetStreamType(stream_id, perspective(),
                                IsIncomingStream(stream_id)) ==
@@ -252,8 +228,7 @@
   // TODO(fkastenholz): IETF Quic does not have static streams and does not
   // make exceptions for them with respect to processing things like
   // STOP_SENDING.
-  if (QuicContainsKey(static_stream_map_, stream_id) ||
-      QuicUtils::IsCryptoStreamId(connection_->transport_version(),
+  if (QuicUtils::IsCryptoStreamId(connection_->transport_version(),
                                   stream_id)) {
     QUIC_DVLOG(1) << ENDPOINT
                   << "Received STOP_SENDING for a static stream, id: "
@@ -350,13 +325,6 @@
     return;
   }
 
-  if (QuicContainsKey(static_stream_map_, stream_id)) {
-    connection()->CloseConnection(
-        QUIC_INVALID_STREAM_ID, "Attempt to reset a static stream",
-        ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
-    return;
-  }
-
   if (visitor_) {
     visitor_->OnRstStreamReceived(frame);
   }
@@ -1081,9 +1049,6 @@
   config_.SetInitialSessionFlowControlWindowToSend(session_window);
   flow_controller_.UpdateReceiveWindowSize(session_window);
   // Inform all existing streams about the new window.
-  for (auto const& kv : static_stream_map_) {
-    kv.second->flow_controller()->UpdateReceiveWindowSize(stream_window);
-  }
   for (auto const& kv : dynamic_stream_map_) {
     kv.second->flow_controller()->UpdateReceiveWindowSize(stream_window);
   }
@@ -1130,9 +1095,6 @@
   }
 
   // Inform all existing streams about the new window.
-  for (auto const& kv : static_stream_map_) {
-    kv.second->UpdateSendWindowOffset(new_window);
-  }
   for (auto const& kv : dynamic_stream_map_) {
     kv.second->UpdateSendWindowOffset(new_window);
   }
@@ -1220,7 +1182,6 @@
   QUIC_DVLOG(1) << ENDPOINT << "num_streams: " << dynamic_stream_map_.size()
                 << ". activating " << stream_id;
   DCHECK(!QuicContainsKey(dynamic_stream_map_, stream_id));
-  DCHECK(!QuicContainsKey(static_stream_map_, stream_id));
   dynamic_stream_map_[stream_id] = std::move(stream);
   if (IsIncomingStream(stream_id)) {
     ++num_dynamic_incoming_streams_;
@@ -1263,10 +1224,6 @@
                                   stream_id)) {
     return GetMutableCryptoStream();
   }
-  StaticStreamMap::iterator it = static_stream_map_.find(stream_id);
-  if (it != static_stream_map_.end()) {
-    return it->second;
-  }
   return GetOrCreateDynamicStream(stream_id);
 }
 
@@ -1321,8 +1278,6 @@
 
 QuicStream* QuicSession::GetOrCreateDynamicStream(
     const QuicStreamId stream_id) {
-  DCHECK(!QuicContainsKey(static_stream_map_, stream_id))
-      << "Attempt to call GetOrCreateDynamicStream for a static stream";
 
   DynamicStreamMap::iterator it = dynamic_stream_map_.find(stream_id);
   if (it != dynamic_stream_map_.end()) {
@@ -1390,8 +1345,7 @@
 bool QuicSession::IsOpenStream(QuicStreamId id) {
   DCHECK_NE(QuicUtils::GetInvalidStreamId(connection_->transport_version()),
             id);
-  if (QuicContainsKey(static_stream_map_, id) ||
-      QuicContainsKey(dynamic_stream_map_, id) ||
+  if (QuicContainsKey(dynamic_stream_map_, id) ||
       QuicContainsKey(pending_stream_map_, id) ||
       QuicUtils::IsCryptoStreamId(connection_->transport_version(), id)) {
     // Stream is active
@@ -1483,11 +1437,6 @@
 }
 
 bool QuicSession::IsStreamFlowControlBlocked() {
-  for (auto const& kv : static_stream_map_) {
-    if (kv.second->flow_controller()->IsBlocked()) {
-      return true;
-    }
-  }
   for (auto const& kv : dynamic_stream_map_) {
     if (kv.second->flow_controller()->IsBlocked()) {
       return true;
@@ -1559,12 +1508,10 @@
 
   // The number of the streams waiting for acks should not be larger than the
   // number of streams.
-  if (static_cast<size_t>(dynamic_stream_map_.size() +
-                          static_stream_map_.size() + zombie_streams_.size()) <
+  if (static_cast<size_t>(dynamic_stream_map_.size() + zombie_streams_.size()) <
       streams_waiting_for_acks_.size()) {
     QUIC_BUG << "More streams are waiting for acks than the number of streams. "
              << "Sizes: dynamic streams: " << dynamic_stream_map_.size()
-             << ", static streams: " << static_stream_map_.size()
              << ", zombie streams: " << zombie_streams_.size()
              << ", vs streams waiting for acks: "
              << streams_waiting_for_acks_.size();
@@ -1572,13 +1519,6 @@
 }
 
 QuicStream* QuicSession::GetStream(QuicStreamId id) const {
-  if (id <= largest_static_stream_id_) {
-    auto static_stream = static_stream_map_.find(id);
-    if (static_stream != static_stream_map_.end()) {
-      return static_stream->second;
-    }
-  }
-
   auto active_stream = dynamic_stream_map_.find(id);
   if (active_stream != dynamic_stream_map_.end()) {
     return active_stream->second.get();
diff --git a/quic/core/quic_session.h b/quic/core/quic_session.h
index 3325506..6bb31e1 100644
--- a/quic/core/quic_session.h
+++ b/quic/core/quic_session.h
@@ -429,8 +429,6 @@
   }
 
  protected:
-  using StaticStreamMap = QuicSmallMap<QuicStreamId, QuicStream*, 2>;
-
   using DynamicStreamMap =
       QuicSmallMap<QuicStreamId, std::unique_ptr<QuicStream>, 10>;
 
@@ -498,14 +496,12 @@
   // ProcessPendingStream().
   virtual bool UsesPendingStreams() const { return false; }
 
-  // Register (|id|, |stream|) with the static stream map. Override previous
-  // registrations with the same id.
-  void RegisterStaticStream(QuicStreamId id, QuicStream* stream);
-  // TODO(renjietang): Replace the original Register method with the new one
-  // once flag is deprecated.
-  void RegisterStaticStreamNew(std::unique_ptr<QuicStream> stream,
-                               bool stream_already_counted);
-  const StaticStreamMap& static_streams() const { return static_stream_map_; }
+  // Transfer ownership of |stream| to dynamic_stream_map_, and register
+  // |stream| as static in stream id manager. |stream_already_counted| is true
+  // if |stream| is created from pending stream and is already known as an open
+  // stream.
+  void RegisterStaticStream(std::unique_ptr<QuicStream> stream,
+                            bool stream_already_counted);
 
   DynamicStreamMap& dynamic_streams() { return dynamic_stream_map_; }
   const DynamicStreamMap& dynamic_streams() const {
@@ -644,10 +640,6 @@
 
   QuicConfig config_;
 
-  // Static streams, such as crypto and header streams. Owned by child classes
-  // that create these streams.
-  StaticStreamMap static_stream_map_;
-
   // Map from StreamId to pointers to streams. Owns the streams.
   DynamicStreamMap dynamic_stream_map_;
 
@@ -699,9 +691,6 @@
   // call stack of OnCanWrite.
   QuicStreamId currently_writing_stream_id_;
 
-  // The largest stream id in |static_stream_map_|.
-  QuicStreamId largest_static_stream_id_;
-
   // Cached value of whether the crypto handshake has been confirmed.
   bool is_handshake_confirmed_;
 
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index 44f5869..0f8420d 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -1298,8 +1298,8 @@
       QuicUtils::GetHeadersStreamId(connection_->transport_version());
   std::unique_ptr<TestStream> fake_headers_stream = QuicMakeUnique<TestStream>(
       headers_stream_id, &session_, /*is_static*/ true, BIDIRECTIONAL);
-  QuicSessionPeer::RegisterStaticStreamNew(&session_,
-                                           std::move(fake_headers_stream));
+  QuicSessionPeer::RegisterStaticStream(&session_,
+                                        std::move(fake_headers_stream));
   // Send two bytes of payload.
   QuicStreamFrame data1(headers_stream_id, true, 0, QuicStringPiece("HT"));
   EXPECT_CALL(*connection_,
@@ -1317,8 +1317,8 @@
       QuicUtils::GetHeadersStreamId(connection_->transport_version());
   std::unique_ptr<TestStream> fake_headers_stream = QuicMakeUnique<TestStream>(
       headers_stream_id, &session_, /*is_static*/ true, BIDIRECTIONAL);
-  QuicSessionPeer::RegisterStaticStreamNew(&session_,
-                                           std::move(fake_headers_stream));
+  QuicSessionPeer::RegisterStaticStream(&session_,
+                                        std::move(fake_headers_stream));
   // Send two bytes of payload.
   QuicRstStreamFrame rst1(kInvalidControlFrameId, headers_stream_id,
                           QUIC_ERROR_PROCESSING_STREAM, 0);
@@ -2502,8 +2502,8 @@
   QuicStreamId stream_id = 0;
   std::unique_ptr<TestStream> fake_static_stream = QuicMakeUnique<TestStream>(
       stream_id, &session_, /*is_static*/ true, BIDIRECTIONAL);
-  QuicSessionPeer::RegisterStaticStreamNew(&session_,
-                                           std::move(fake_static_stream));
+  QuicSessionPeer::RegisterStaticStream(&session_,
+                                        std::move(fake_static_stream));
   // Check that a stream id in the static stream map is ignored.
   // Note that the notion of a static stream is Google-specific.
   QuicStopSendingFrame frame(1, stream_id, 123);
diff --git a/quic/test_tools/quic_server_session_base_peer.h b/quic/test_tools/quic_server_session_base_peer.h
index d2a21a6..b29fe46 100644
--- a/quic/test_tools/quic_server_session_base_peer.h
+++ b/quic/test_tools/quic_server_session_base_peer.h
@@ -21,11 +21,6 @@
   static void SetCryptoStream(QuicServerSessionBase* s,
                               QuicCryptoServerStream* crypto_stream) {
     s->crypto_stream_.reset(crypto_stream);
-    if (!QuicVersionUsesCryptoFrames(s->connection()->transport_version())) {
-      s->RegisterStaticStream(
-          QuicUtils::GetCryptoStreamId(s->connection()->transport_version()),
-          crypto_stream);
-    }
   }
   static bool IsBandwidthResumptionEnabled(QuicServerSessionBase* s) {
     return s->bandwidth_resumption_enabled_;
diff --git a/quic/test_tools/quic_session_peer.cc b/quic/test_tools/quic_session_peer.cc
index 3d4c9f3..018d35a 100644
--- a/quic/test_tools/quic_session_peer.cc
+++ b/quic/test_tools/quic_session_peer.cc
@@ -130,12 +130,6 @@
 }
 
 // static
-QuicSession::StaticStreamMap& QuicSessionPeer::static_streams(
-    QuicSession* session) {
-  return session->static_stream_map_;
-}
-
-// static
 QuicSession::DynamicStreamMap& QuicSessionPeer::dynamic_streams(
     QuicSession* session) {
   return session->dynamic_streams();
@@ -167,17 +161,9 @@
 
 // static
 void QuicSessionPeer::RegisterStaticStream(QuicSession* session,
-                                           QuicStreamId id,
-                                           QuicStream* stream) {
-  return session->RegisterStaticStream(id, stream);
-}
-
-// static
-void QuicSessionPeer::RegisterStaticStreamNew(
-    QuicSession* session,
-    std::unique_ptr<QuicStream> stream) {
-  return session->RegisterStaticStreamNew(std::move(stream),
-                                          /*stream_already_counted = */ false);
+                                           std::unique_ptr<QuicStream> stream) {
+  return session->RegisterStaticStream(std::move(stream),
+                                       /*stream_already_counted = */ false);
 }
 
 // static
diff --git a/quic/test_tools/quic_session_peer.h b/quic/test_tools/quic_session_peer.h
index 3828981..f414f19 100644
--- a/quic/test_tools/quic_session_peer.h
+++ b/quic/test_tools/quic_session_peer.h
@@ -56,7 +56,6 @@
                                               QuicStreamId stream_id);
   static std::map<QuicStreamId, QuicStreamOffset>&
   GetLocallyClosedStreamsHighestOffset(QuicSession* session);
-  static QuicSession::StaticStreamMap& static_streams(QuicSession* session);
   static QuicSession::DynamicStreamMap& dynamic_streams(QuicSession* session);
   static const QuicSession::ClosedStreams& closed_streams(QuicSession* session);
   static QuicSession::ZombieStreamMap& zombie_streams(QuicSession* session);
@@ -65,9 +64,6 @@
   static void ActivateStream(QuicSession* session,
                              std::unique_ptr<QuicStream> stream);
   static void RegisterStaticStream(QuicSession* session,
-                                   QuicStreamId stream_id,
-                                   QuicStream* stream);
-  static void RegisterStaticStreamNew(QuicSession* session,
                                       std::unique_ptr<QuicStream> stream);
 
   // Discern the state of a stream.  Exactly one of these should be true at a
diff --git a/quic/test_tools/quic_spdy_session_peer.cc b/quic/test_tools/quic_spdy_session_peer.cc
index 4c5b9fd..affdbd6 100644
--- a/quic/test_tools/quic_spdy_session_peer.cc
+++ b/quic/test_tools/quic_spdy_session_peer.cc
@@ -16,15 +16,6 @@
   return session->headers_stream();
 }
 
-// static
-void QuicSpdySessionPeer::SetHeadersStream(QuicSpdySession* session,
-                                           QuicHeadersStream* headers_stream) {
-  session->headers_stream_.reset(headers_stream);
-  if (headers_stream != nullptr) {
-    session->RegisterStaticStream(headers_stream->id(), headers_stream);
-  }
-}
-
 void QuicSpdySessionPeer::SetUnownedHeadersStream(
     QuicSpdySession* session,
     QuicHeadersStream* headers_stream) {
diff --git a/quic/test_tools/quic_spdy_session_peer.h b/quic/test_tools/quic_spdy_session_peer.h
index 49795ba..f97b264 100644
--- a/quic/test_tools/quic_spdy_session_peer.h
+++ b/quic/test_tools/quic_spdy_session_peer.h
@@ -24,8 +24,6 @@
   QuicSpdySessionPeer() = delete;
 
   static QuicHeadersStream* GetHeadersStream(QuicSpdySession* session);
-  static void SetHeadersStream(QuicSpdySession* session,
-                               QuicHeadersStream* headers_stream);
   static void SetUnownedHeadersStream(QuicSpdySession* session,
                                       QuicHeadersStream* headers_stream);
   static const spdy::SpdyFramer& GetSpdyFramer(QuicSpdySession* session);
diff --git a/quic/tools/quic_simple_server_session_test.cc b/quic/tools/quic_simple_server_session_test.cc
index c1bc8ac..eeb9ce3 100644
--- a/quic/tools/quic_simple_server_session_test.cc
+++ b/quic/tools/quic_simple_server_session_test.cc
@@ -58,11 +58,6 @@
   static void SetCryptoStream(QuicSimpleServerSession* s,
                               QuicCryptoServerStream* crypto_stream) {
     s->crypto_stream_.reset(crypto_stream);
-    if (!QuicVersionUsesCryptoFrames(s->connection()->transport_version())) {
-      s->RegisterStaticStream(
-          QuicUtils::GetCryptoStreamId(s->connection()->transport_version()),
-          crypto_stream);
-    }
   }
 
   static QuicSpdyStream* CreateIncomingStream(QuicSimpleServerSession* s,