diff --git a/evm-tests/src/contracts/subnet.ts b/evm-tests/src/contracts/subnet.ts
index b5a5a9dcbc..a55bd5030f 100644
--- a/evm-tests/src/contracts/subnet.ts
+++ b/evm-tests/src/contracts/subnet.ts
@@ -663,24 +663,6 @@ export const ISubnetABI = [
         stateMutability: "payable",
         type: "function",
     },
-    {
-        inputs: [
-            {
-                internalType: "uint16",
-                name: "netuid",
-                type: "uint16",
-            },
-            {
-                internalType: "uint16",
-                name: "maxWeightLimit",
-                type: "uint16",
-            },
-        ],
-        name: "setMaxWeightLimit",
-        outputs: [],
-        stateMutability: "payable",
-        type: "function",
-    },
     {
         inputs: [
             {
diff --git a/evm-tests/test/subnet.precompile.hyperparameter.test.ts b/evm-tests/test/subnet.precompile.hyperparameter.test.ts
index e3b5708e50..ebb3bb4598 100644
--- a/evm-tests/test/subnet.precompile.hyperparameter.test.ts
+++ b/evm-tests/test/subnet.precompile.hyperparameter.test.ts
@@ -208,25 +208,17 @@ describe("Test the Subnet precompile contract", () => {
         assert.equal(valueFromContract, onchainValue);
     })
 
-    it("Can set maxWeightLimit parameter", async () => {
+    it("Returns constant maxWeightLimit", async () => {
 
         const totalNetwork = await api.query.SubtensorModule.TotalNetworks.getValue()
         const contract = new ethers.Contract(ISUBNET_ADDRESS, ISubnetABI, wallet);
         const netuid = totalNetwork - 1;
 
-        const newValue = 106;
-        const tx = await contract.setMaxWeightLimit(netuid, newValue);
-        await tx.wait();
-
-        let onchainValue = await api.query.SubtensorModule.MaxWeightsLimit.getValue(netuid)
-
-
-        let valueFromContract = Number(
+        const valueFromContract = Number(
             await contract.getMaxWeightLimit(netuid)
         );
 
-        assert.equal(valueFromContract, newValue)
-        assert.equal(valueFromContract, onchainValue);
+        assert.equal(valueFromContract, 0xFFFF)
     })
 
     it("Can set immunityPeriod parameter", async () => {
diff --git a/hyperparameters.md b/hyperparameters.md
index 2d69a1f378..870f343a3b 100644
--- a/hyperparameters.md
+++ b/hyperparameters.md
@@ -2,6 +2,7 @@
 ```rust
 DefaultTake: u16 = 11_796; // 18% honest number.
 TxRateLimit: u64 = 1; // [1 @ 64,888]
+MaxWeightsLimit: u16 = u16::MAX; // constant limit
 ```
 
 ### netuid 1 (text_prompting)
@@ -13,7 +14,6 @@ MaxAllowedUids: u16 = 1024;
 Issuance: u64 = 0;
 MinAllowedWeights: u16 = 8;
 EmissionValue: u64 = 142_223_000;
-MaxWeightsLimit: 455; // 455/2^16 = 0.0069
 ValidatorBatchSize: u16 = 1;
 ValidatorSequenceLen: u16 = 2048; // 2048
 ValidatorEpochLen: u16 = 100;
@@ -54,7 +54,6 @@ MaxAllowedUids: u16 = 4096;
 Issuance: u64 = 0;
 MinAllowedWeights: u16 = 50;
 EmissionValue: u64 = 857_777_000;
-MaxWeightsLimit: u16 = 655; // 655/2^16 = 0.01 [655 @ 7,160]
 ValidatorBatchSize: u16 = 32; // 32
 ValidatorSequenceLen: u16 = 256; // 256
 ValidatorEpochLen: u16 = 250; // [250 @ 7,161]
diff --git a/pallets/admin-utils/src/benchmarking.rs b/pallets/admin-utils/src/benchmarking.rs
index 7e6e17dd5c..08589e530b 100644
--- a/pallets/admin-utils/src/benchmarking.rs
+++ b/pallets/admin-utils/src/benchmarking.rs
@@ -292,19 +292,6 @@ mod benchmarks {
 		_(RawOrigin::Root, 1u16.into()/*netuid*/, 100u16/*immunity_period*/)/*sudo_set_immunity_period*/;
     }
 
-    #[benchmark]
-    fn sudo_set_max_weight_limit() {
-        // disable admin freeze window
-        pallet_subtensor::Pallet::<T>::set_admin_freeze_window(0);
-        pallet_subtensor::Pallet::<T>::init_new_network(
-            1u16.into(), /*netuid*/
-            1u16,        /*tempo*/
-        );
-
-        #[extrinsic_call]
-		_(RawOrigin::Root, 1u16.into()/*netuid*/, 100u16/*max_weight_limit*/)/*sudo_set_max_weight_limit*/;
-    }
-
     #[benchmark]
     fn sudo_set_max_registrations_per_block() {
         // disable admin freeze window
diff --git a/pallets/admin-utils/src/lib.rs b/pallets/admin-utils/src/lib.rs
index 66e7eab318..e198979e5d 100644
--- a/pallets/admin-utils/src/lib.rs
+++ b/pallets/admin-utils/src/lib.rs
@@ -426,40 +426,6 @@ pub mod pallet {
             Ok(())
         }
 
-        /// The extrinsic sets the adjustment beta for a subnet.
-        /// It is only callable by the root account or subnet owner.
-        /// The extrinsic will call the Subtensor pallet to set the adjustment beta.
-        #[pallet::call_index(12)]
-        #[pallet::weight(Weight::from_parts(26_890_000, 0)
-        .saturating_add(<T as frame_system::Config>::DbWeight::get().reads(3_u64))
-        .saturating_add(<T as frame_system::Config>::DbWeight::get().writes(1_u64)))]
-        pub fn sudo_set_max_weight_limit(
-            origin: OriginFor<T>,
-            netuid: NetUid,
-            max_weight_limit: u16,
-        ) -> DispatchResult {
-            let maybe_owner = pallet_subtensor::Pallet::<T>::ensure_sn_owner_or_root_with_limits(
-                origin,
-                netuid,
-                &[Hyperparameter::MaxWeightLimit.into()],
-            )?;
-
-            ensure!(
-                pallet_subtensor::Pallet::<T>::if_subnet_exist(netuid),
-                Error::<T>::SubnetDoesNotExist
-            );
-            pallet_subtensor::Pallet::<T>::set_max_weight_limit(netuid, max_weight_limit);
-            pallet_subtensor::Pallet::<T>::record_owner_rl(
-                maybe_owner,
-                netuid,
-                &[Hyperparameter::MaxWeightLimit.into()],
-            );
-            log::debug!(
-                "MaxWeightLimitSet( netuid: {netuid:?} max_weight_limit: {max_weight_limit:?} ) "
-            );
-            Ok(())
-        }
-
         /// The extrinsic sets the immunity period for a subnet.
         /// It is only callable by the root account or subnet owner.
         /// The extrinsic will call the Subtensor pallet to set the immunity period.
diff --git a/pallets/admin-utils/src/tests/mock.rs b/pallets/admin-utils/src/tests/mock.rs
index ed62be55d8..0140808baa 100644
--- a/pallets/admin-utils/src/tests/mock.rs
+++ b/pallets/admin-utils/src/tests/mock.rs
@@ -77,7 +77,6 @@ pub type UncheckedExtrinsic = TestXt<RuntimeCall, ()>;
 parameter_types! {
     pub const InitialMinAllowedWeights: u16 = 0;
     pub const InitialEmissionValue: u16 = 0;
-    pub const InitialMaxWeightsLimit: u16 = u16::MAX;
     pub BlockWeights: limits::BlockWeights = limits::BlockWeights::with_sensible_defaults(
         Weight::from_parts(2_000_000_000_000, u64::MAX),
         Perbill::from_percent(75),
@@ -162,7 +161,6 @@ impl pallet_subtensor::Config for Test {
     type Scheduler = Scheduler;
     type InitialMinAllowedWeights = InitialMinAllowedWeights;
     type InitialEmissionValue = InitialEmissionValue;
-    type InitialMaxWeightsLimit = InitialMaxWeightsLimit;
     type InitialTempo = InitialTempo;
     type InitialDifficulty = InitialDifficulty;
     type InitialAdjustmentInterval = InitialAdjustmentInterval;
diff --git a/pallets/admin-utils/src/tests/mod.rs b/pallets/admin-utils/src/tests/mod.rs
index 4e534c3210..f0ba59e285 100644
--- a/pallets/admin-utils/src/tests/mod.rs
+++ b/pallets/admin-utils/src/tests/mod.rs
@@ -391,39 +391,6 @@ fn test_sudo_subnet_owner_cut() {
     });
 }
 
-#[test]
-fn test_sudo_set_max_weight_limit() {
-    new_test_ext().execute_with(|| {
-        let netuid = NetUid::from(1);
-        let to_be_set: u16 = 10;
-        add_network(netuid, 10);
-        let init_value: u16 = SubtensorModule::get_max_weight_limit(netuid);
-        assert_eq!(
-            AdminUtils::sudo_set_max_weight_limit(
-                <<Test as Config>::RuntimeOrigin>::signed(U256::from(1)),
-                netuid,
-                to_be_set
-            ),
-            Err(DispatchError::BadOrigin)
-        );
-        assert_eq!(
-            AdminUtils::sudo_set_max_weight_limit(
-                <<Test as Config>::RuntimeOrigin>::root(),
-                netuid.next(),
-                to_be_set
-            ),
-            Err(Error::<Test>::SubnetDoesNotExist.into())
-        );
-        assert_eq!(SubtensorModule::get_max_weight_limit(netuid), init_value);
-        assert_ok!(AdminUtils::sudo_set_max_weight_limit(
-            <<Test as Config>::RuntimeOrigin>::root(),
-            netuid,
-            to_be_set
-        ));
-        assert_eq!(SubtensorModule::get_max_weight_limit(netuid), to_be_set);
-    });
-}
-
 #[test]
 fn test_sudo_set_issuance() {
     new_test_ext().execute_with(|| {
diff --git a/pallets/subtensor/src/coinbase/root.rs b/pallets/subtensor/src/coinbase/root.rs
index 61d5860354..b220b47604 100644
--- a/pallets/subtensor/src/coinbase/root.rs
+++ b/pallets/subtensor/src/coinbase/root.rs
@@ -284,7 +284,6 @@ impl<T: Config> Pallet<T> {
         MaxAllowedUids::<T>::remove(netuid);
         ImmunityPeriod::<T>::remove(netuid);
         ActivityCutoff::<T>::remove(netuid);
-        MaxWeightsLimit::<T>::remove(netuid);
         MinAllowedWeights::<T>::remove(netuid);
         RegistrationsThisInterval::<T>::remove(netuid);
         POWRegistrationsThisInterval::<T>::remove(netuid);
diff --git a/pallets/subtensor/src/lib.rs b/pallets/subtensor/src/lib.rs
index ef475b1033..ca55a0ab52 100644
--- a/pallets/subtensor/src/lib.rs
+++ b/pallets/subtensor/src/lib.rs
@@ -650,11 +650,6 @@ pub mod pallet {
         T::InitialActivityCutoff::get()
     }
     #[pallet::type_value]
-    /// Default maximum weights limit.
-    pub fn DefaultMaxWeightsLimit<T: Config>() -> u16 {
-        T::InitialMaxWeightsLimit::get()
-    }
-    #[pallet::type_value]
     /// Default weights version key.
     pub fn DefaultWeightsVersionKey<T: Config>() -> u64 {
         T::InitialWeightsVersionKey::get()
@@ -1402,6 +1397,11 @@ pub mod pallet {
     /// --- MAP ( netuid ) --> activity_cutoff
     pub type ActivityCutoff<T> =
         StorageMap<_, Identity, NetUid, u16, ValueQuery, DefaultActivityCutoff<T>>;
+    #[pallet::type_value]
+    /// Default maximum weights limit.
+    pub fn DefaultMaxWeightsLimit<T: Config>() -> u16 {
+        u16::MAX
+    }
     #[pallet::storage]
     /// --- MAP ( netuid ) --> max_weight_limit
     pub type MaxWeightsLimit<T> =
diff --git a/pallets/subtensor/src/macros/config.rs b/pallets/subtensor/src/macros/config.rs
index c449742905..a735bde1e1 100644
--- a/pallets/subtensor/src/macros/config.rs
+++ b/pallets/subtensor/src/macros/config.rs
@@ -72,9 +72,6 @@ mod config {
         /// Initial Emission Ratio.
         #[pallet::constant]
         type InitialEmissionValue: Get<u16>;
-        /// Initial max weight limit.
-        #[pallet::constant]
-        type InitialMaxWeightsLimit: Get<u16>;
         /// Tempo for each network.
         #[pallet::constant]
         type InitialTempo: Get<u16>;
diff --git a/pallets/subtensor/src/macros/errors.rs b/pallets/subtensor/src/macros/errors.rs
index 9d9b7a70f5..80e9c2a3ee 100644
--- a/pallets/subtensor/src/macros/errors.rs
+++ b/pallets/subtensor/src/macros/errors.rs
@@ -71,7 +71,7 @@ mod errors {
         /// The supplied PoW hash seal does not match the supplied work.
         InvalidSeal,
         /// The dispatch is attempting to set weights on chain with weight value exceeding the
-        /// MaxWeightLimit (max_weight_limit subnet hyperparameter).
+        /// configured max weight limit (currently `u16::MAX`).
         MaxWeightExceeded,
         /// The hotkey is attempting to become a delegate when the hotkey is already a delegate.
         HotKeyAlreadyDelegate,
diff --git a/pallets/subtensor/src/macros/events.rs b/pallets/subtensor/src/macros/events.rs
index 07232cbc14..a784273f5a 100644
--- a/pallets/subtensor/src/macros/events.rs
+++ b/pallets/subtensor/src/macros/events.rs
@@ -50,7 +50,8 @@ mod events {
         BulkBalancesSet(u16, u16),
         /// max allowed uids has been set for a subnetwork.
         MaxAllowedUidsSet(NetUid, u16),
-        /// the max weight limit has been set for a subnetwork.
+        #[deprecated(note = "Max weight limit is now a constant and this event is unused")]
+        /// DEPRECATED: max weight limit updates are no longer supported.
         MaxWeightLimitSet(NetUid, u16),
         /// the difficulty has been set for a subnet.
         DifficultySet(NetUid, u64),
diff --git a/pallets/subtensor/src/macros/genesis.rs b/pallets/subtensor/src/macros/genesis.rs
index b9378e38f6..9d830e36ad 100644
--- a/pallets/subtensor/src/macros/genesis.rs
+++ b/pallets/subtensor/src/macros/genesis.rs
@@ -29,9 +29,6 @@ mod genesis {
             // Set the min allowed weights to zero, no weights restrictions.
             MinAllowedWeights::<T>::insert(NetUid::ROOT, 0);
 
-            // Set the max weight limit to infitiy, no weight restrictions.
-            MaxWeightsLimit::<T>::insert(NetUid::ROOT, u16::MAX);
-
             // Add default root tempo.
             Tempo::<T>::insert(NetUid::ROOT, 100);
 
@@ -59,7 +56,6 @@ mod genesis {
             MaxAllowedUids::<T>::insert(netuid, 256u16);
             MaxAllowedValidators::<T>::insert(netuid, 64u16);
             MinAllowedWeights::<T>::insert(netuid, 0);
-            MaxWeightsLimit::<T>::insert(netuid, u16::MAX);
             Tempo::<T>::insert(netuid, 100);
             NetworkRegistrationAllowed::<T>::insert(netuid, true);
             SubnetOwner::<T>::insert(netuid, hotkey.clone());
diff --git a/pallets/subtensor/src/migrations/migrate_create_root_network.rs b/pallets/subtensor/src/migrations/migrate_create_root_network.rs
index c9d069b451..6cca34f815 100644
--- a/pallets/subtensor/src/migrations/migrate_create_root_network.rs
+++ b/pallets/subtensor/src/migrations/migrate_create_root_network.rs
@@ -64,9 +64,6 @@ pub fn migrate_create_root_network<T: Config>() -> Weight {
     // Set the minimum allowed weights to zero (no weight restrictions)
     MinAllowedWeights::<T>::insert(NetUid::ROOT, 0);
 
-    // Set the maximum weight limit to u16::MAX (no weight restrictions)
-    MaxWeightsLimit::<T>::insert(NetUid::ROOT, u16::MAX);
-
     // Set default root tempo
     Tempo::<T>::insert(NetUid::ROOT, 100);
 
@@ -80,7 +77,7 @@ pub fn migrate_create_root_network<T: Config>() -> Weight {
     // WeightsSetRateLimit::<T>::insert(NetUid::ROOT, 7200);
 
     // Accrue weight for database writes
-    weight.saturating_accrue(T::DbWeight::get().writes(8));
+    weight.saturating_accrue(T::DbWeight::get().writes(7));
 
     // Remove all existing triumvirate votes and senate members
     remove_prefix::<T>("Triumvirate", "Votes", &mut weight);
diff --git a/pallets/subtensor/src/migrations/migrate_delete_subnet_21.rs b/pallets/subtensor/src/migrations/migrate_delete_subnet_21.rs
index c4e79692ac..260904395d 100644
--- a/pallets/subtensor/src/migrations/migrate_delete_subnet_21.rs
+++ b/pallets/subtensor/src/migrations/migrate_delete_subnet_21.rs
@@ -100,13 +100,12 @@ pub fn migrate_delete_subnet_21<T: Config>() -> Weight {
         MaxAllowedUids::<T>::remove(netuid);
         ImmunityPeriod::<T>::remove(netuid);
         ActivityCutoff::<T>::remove(netuid);
-        MaxWeightsLimit::<T>::remove(netuid);
         MinAllowedWeights::<T>::remove(netuid);
         RegistrationsThisInterval::<T>::remove(netuid);
         POWRegistrationsThisInterval::<T>::remove(netuid);
         BurnRegistrationsThisInterval::<T>::remove(netuid);
 
-        weight.saturating_accrue(T::DbWeight::get().writes(12));
+        weight.saturating_accrue(T::DbWeight::get().writes(10));
 
         // Update storage version
         StorageVersion::new(new_storage_version).put::<Pallet<T>>();
diff --git a/pallets/subtensor/src/migrations/migrate_delete_subnet_3.rs b/pallets/subtensor/src/migrations/migrate_delete_subnet_3.rs
index 3470004362..0cda0f0e06 100644
--- a/pallets/subtensor/src/migrations/migrate_delete_subnet_3.rs
+++ b/pallets/subtensor/src/migrations/migrate_delete_subnet_3.rs
@@ -102,13 +102,12 @@ pub fn migrate_delete_subnet_3<T: Config>() -> Weight {
         MaxAllowedUids::<T>::remove(netuid);
         ImmunityPeriod::<T>::remove(netuid);
         ActivityCutoff::<T>::remove(netuid);
-        MaxWeightsLimit::<T>::remove(netuid);
         MinAllowedWeights::<T>::remove(netuid);
         RegistrationsThisInterval::<T>::remove(netuid);
         POWRegistrationsThisInterval::<T>::remove(netuid);
         BurnRegistrationsThisInterval::<T>::remove(netuid);
 
-        weight.saturating_accrue(T::DbWeight::get().writes(12));
+        weight.saturating_accrue(T::DbWeight::get().writes(10));
 
         // Update storage version
         StorageVersion::new(new_storage_version).put::<Pallet<T>>();
diff --git a/pallets/subtensor/src/subnets/subnet.rs b/pallets/subtensor/src/subnets/subnet.rs
index 7676e0c557..4185aee624 100644
--- a/pallets/subtensor/src/subnets/subnet.rs
+++ b/pallets/subtensor/src/subnets/subnet.rs
@@ -275,7 +275,6 @@ impl<T: Config> Pallet<T> {
         Self::set_max_allowed_uids(netuid, 256);
         Self::set_max_allowed_validators(netuid, 64);
         Self::set_min_allowed_weights(netuid, 1);
-        Self::set_max_weight_limit(netuid, u16::MAX);
         Self::set_adjustment_interval(netuid, 360);
         Self::set_target_registrations_per_interval(netuid, 1);
         Self::set_adjustment_alpha(netuid, 17_893_341_751_498_265_066); // 18_446_744_073_709_551_615 * 0.97 = 17_893_341_751_498_265_066
@@ -302,9 +301,6 @@ impl<T: Config> Pallet<T> {
         if !ActivityCutoff::<T>::contains_key(netuid) {
             ActivityCutoff::<T>::insert(netuid, ActivityCutoff::<T>::get(netuid));
         }
-        if !MaxWeightsLimit::<T>::contains_key(netuid) {
-            MaxWeightsLimit::<T>::insert(netuid, MaxWeightsLimit::<T>::get(netuid));
-        }
         if !MinAllowedWeights::<T>::contains_key(netuid) {
             MinAllowedWeights::<T>::insert(netuid, MinAllowedWeights::<T>::get(netuid));
         }
diff --git a/pallets/subtensor/src/subnets/weights.rs b/pallets/subtensor/src/subnets/weights.rs
index 61b64df137..f1a2df56e2 100644
--- a/pallets/subtensor/src/subnets/weights.rs
+++ b/pallets/subtensor/src/subnets/weights.rs
@@ -1203,14 +1203,14 @@ impl<T: Config> Pallet<T> {
         weights
     }
 
-    /// Returns False if the weights exceed the max_weight_limit for this network.
+    /// Returns False if the weights exceed the configured max weight limit for this network.
     pub fn max_weight_limited(netuid: NetUid, uid: u16, uids: &[u16], weights: &[u16]) -> bool {
         // Allow self weights to exceed max weight limit.
         if Self::is_self_weight(uid, uids, weights) {
             return true;
         }
 
-        // If the max weight limit it u16 max, return true.
+        // If the max weight limit it u16 max, return true (current constant).
         let max_weight_limit: u16 = Self::get_max_weight_limit(netuid);
         if max_weight_limit == u16::MAX {
             return true;
diff --git a/pallets/subtensor/src/tests/epoch.rs b/pallets/subtensor/src/tests/epoch.rs
index 77ba37c9c1..cdf44df645 100644
--- a/pallets/subtensor/src/tests/epoch.rs
+++ b/pallets/subtensor/src/tests/epoch.rs
@@ -1024,7 +1024,6 @@ fn test_bonds() {
 		SubtensorModule::set_target_registrations_per_interval(netuid, n);
 		SubtensorModule::set_weights_set_rate_limit( netuid, 0 );
         SubtensorModule::set_min_allowed_weights( netuid, 1 );
-        SubtensorModule::set_max_weight_limit( netuid, u16::MAX );
 		SubtensorModule::set_bonds_penalty(netuid, u16::MAX);
 
 
@@ -1370,7 +1369,6 @@ fn test_active_stake() {
         SubtensorModule::set_max_registrations_per_block(netuid, n);
         SubtensorModule::set_target_registrations_per_interval(netuid, n);
         SubtensorModule::set_min_allowed_weights(netuid, 0);
-        SubtensorModule::set_max_weight_limit(netuid, u16::MAX);
 
         // === Register [validator1, validator2, server1, server2]
         for key in 0..n as u64 {
@@ -1587,7 +1585,6 @@ fn test_outdated_weights() {
         SubtensorModule::set_max_registrations_per_block(netuid, n);
         SubtensorModule::set_target_registrations_per_interval(netuid, n);
         SubtensorModule::set_min_allowed_weights(netuid, 0);
-        SubtensorModule::set_max_weight_limit(netuid, u16::MAX);
         SubtensorModule::set_bonds_penalty(netuid, u16::MAX);
         assert_eq!(SubtensorModule::get_registrations_this_block(netuid), 0);
 
@@ -1777,7 +1774,6 @@ fn test_zero_weights() {
         SubtensorModule::set_max_registrations_per_block(netuid, n);
         SubtensorModule::set_target_registrations_per_interval(netuid, n);
         SubtensorModule::set_min_allowed_weights(netuid, 0);
-        SubtensorModule::set_max_weight_limit(netuid, u16::MAX);
 
         // === Register [validator, server]
         for key in 0..n as u64 {
@@ -1980,7 +1976,6 @@ fn test_deregistered_miner_bonds() {
         SubtensorModule::set_max_registrations_per_block(netuid, n);
         SubtensorModule::set_target_registrations_per_interval(netuid, n);
         SubtensorModule::set_min_allowed_weights(netuid, 0);
-        SubtensorModule::set_max_weight_limit(netuid, u16::MAX);
         SubtensorModule::set_bonds_penalty(netuid, u16::MAX);
         assert_eq!(SubtensorModule::get_registrations_this_block(netuid), 0);
 
@@ -2700,7 +2695,6 @@ fn setup_yuma_3_scenario(netuid: NetUid, n: u16, sparse: bool, max_stake: u64, s
     SubtensorModule::set_target_registrations_per_interval(netuid, n);
     SubtensorModule::set_weights_set_rate_limit(netuid, 0);
     SubtensorModule::set_min_allowed_weights(netuid, 1);
-    SubtensorModule::set_max_weight_limit(netuid, u16::MAX);
     SubtensorModule::set_bonds_penalty(netuid, 0);
     SubtensorModule::set_alpha_sigmoid_steepness(netuid, 1000);
     SubtensorModule::set_bonds_moving_average(netuid, 975_000);
diff --git a/pallets/subtensor/src/tests/mock.rs b/pallets/subtensor/src/tests/mock.rs
index 73f8581d5e..9d028d76ab 100644
--- a/pallets/subtensor/src/tests/mock.rs
+++ b/pallets/subtensor/src/tests/mock.rs
@@ -151,7 +151,6 @@ parameter_types! {
 parameter_types! {
     pub const InitialMinAllowedWeights: u16 = 0;
     pub const InitialEmissionValue: u16 = 0;
-    pub const InitialMaxWeightsLimit: u16 = u16::MAX;
     pub BlockWeights: limits::BlockWeights = limits::BlockWeights::with_sensible_defaults(
         Weight::from_parts(2_000_000_000_000, u64::MAX),
         Perbill::from_percent(75),
@@ -235,7 +234,6 @@ impl crate::Config for Test {
     type Scheduler = Scheduler;
     type InitialMinAllowedWeights = InitialMinAllowedWeights;
     type InitialEmissionValue = InitialEmissionValue;
-    type InitialMaxWeightsLimit = InitialMaxWeightsLimit;
     type InitialTempo = InitialTempo;
     type InitialDifficulty = InitialDifficulty;
     type InitialAdjustmentInterval = InitialAdjustmentInterval;
diff --git a/pallets/subtensor/src/tests/networks.rs b/pallets/subtensor/src/tests/networks.rs
index d7b0e15ea0..67d9f90887 100644
--- a/pallets/subtensor/src/tests/networks.rs
+++ b/pallets/subtensor/src/tests/networks.rs
@@ -327,7 +327,6 @@ fn dissolve_clears_all_per_subnet_storages() {
         MaxAllowedUids::<Test>::insert(net, 1u16);
         ImmunityPeriod::<Test>::insert(net, 1u16);
         ActivityCutoff::<Test>::insert(net, 1u16);
-        MaxWeightsLimit::<Test>::insert(net, 1u16);
         MinAllowedWeights::<Test>::insert(net, 1u16);
 
         RegistrationsThisInterval::<Test>::insert(net, 1u16);
@@ -479,7 +478,6 @@ fn dissolve_clears_all_per_subnet_storages() {
         assert!(!MaxAllowedUids::<Test>::contains_key(net));
         assert!(!ImmunityPeriod::<Test>::contains_key(net));
         assert!(!ActivityCutoff::<Test>::contains_key(net));
-        assert!(!MaxWeightsLimit::<Test>::contains_key(net));
         assert!(!MinAllowedWeights::<Test>::contains_key(net));
 
         assert!(!RegistrationsThisInterval::<Test>::contains_key(net));
diff --git a/pallets/subtensor/src/tests/weights.rs b/pallets/subtensor/src/tests/weights.rs
index d703cb0840..a71a225dc7 100644
--- a/pallets/subtensor/src/tests/weights.rs
+++ b/pallets/subtensor/src/tests/weights.rs
@@ -731,7 +731,6 @@ fn test_weights_err_no_validator_permit() {
         add_network_disable_commit_reveal(netuid, tempo, 0);
         SubtensorModule::set_min_allowed_weights(netuid, 0);
         SubtensorModule::set_max_allowed_uids(netuid, 3);
-        SubtensorModule::set_max_weight_limit(netuid, u16::MAX);
         register_ok_neuron(netuid, hotkey_account_id, U256::from(66), 0);
         register_ok_neuron(netuid, U256::from(1), U256::from(1), 65555);
         register_ok_neuron(netuid, U256::from(2), U256::from(2), 75555);
@@ -917,7 +916,6 @@ fn test_weights_err_setting_weights_too_fast() {
         add_network_disable_commit_reveal(netuid, tempo, 0);
         SubtensorModule::set_min_allowed_weights(netuid, 0);
         SubtensorModule::set_max_allowed_uids(netuid, 3);
-        SubtensorModule::set_max_weight_limit(netuid, u16::MAX);
         register_ok_neuron(netuid, hotkey_account_id, U256::from(66), 0);
         register_ok_neuron(netuid, U256::from(1), U256::from(1), 65555);
         register_ok_neuron(netuid, U256::from(2), U256::from(2), 75555);
@@ -1060,95 +1058,6 @@ fn test_weights_err_has_duplicate_ids() {
 
 // SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor --lib -- tests::weights::test_weights_err_max_weight_limit --exact --show-output --nocapture
 // Test ensures weights cannot exceed max weight limit.
-#[test]
-fn test_weights_err_max_weight_limit() {
-    //TO DO SAM: uncomment when we implement run_to_block fn
-    new_test_ext(0).execute_with(|| {
-        // Add network.
-        let netuid = NetUid::from(1);
-        let tempo: u16 = 100;
-        add_network_disable_commit_reveal(netuid, tempo, 0);
-
-        // Set params.
-        SubtensorModule::set_max_allowed_uids(netuid, 5);
-        SubtensorModule::set_target_registrations_per_interval(netuid, 5);
-        SubtensorModule::set_max_weight_limit(netuid, u16::MAX / 5);
-        SubtensorModule::set_min_allowed_weights(netuid, 0);
-
-        // Add 5 accounts.
-        println!("+Registering: net:{:?}, cold:{:?}, hot:{:?}", netuid, 0, 0);
-        register_ok_neuron(netuid, U256::from(0), U256::from(0), 55555);
-        let neuron_uid: u16 = SubtensorModule::get_uid_for_net_and_hotkey(netuid, &U256::from(0))
-            .expect("Not registered.");
-        SubtensorModule::set_validator_permit_for_uid(netuid, neuron_uid, true);
-        assert_eq!(SubtensorModule::get_subnetwork_n(netuid), 1);
-        assert!(SubtensorModule::is_hotkey_registered_on_network(
-            netuid,
-            &U256::from(0)
-        ));
-        step_block(1);
-
-        println!("+Registering: net:{:?}, cold:{:?}, hot:{:?}", netuid, 1, 1);
-        register_ok_neuron(netuid, U256::from(1), U256::from(1), 65555);
-        assert!(SubtensorModule::is_hotkey_registered_on_network(
-            netuid,
-            &U256::from(1)
-        ));
-        assert_eq!(SubtensorModule::get_subnetwork_n(netuid), 2);
-        step_block(1);
-
-        println!("+Registering: net:{:?}, cold:{:?}, hot:{:?}", netuid, 2, 2);
-        register_ok_neuron(netuid, U256::from(2), U256::from(2), 75555);
-        assert!(SubtensorModule::is_hotkey_registered_on_network(
-            netuid,
-            &U256::from(2)
-        ));
-        assert_eq!(SubtensorModule::get_subnetwork_n(netuid), 3);
-        step_block(1);
-
-        println!("+Registering: net:{:?}, cold:{:?}, hot:{:?}", netuid, 3, 3);
-        register_ok_neuron(netuid, U256::from(3), U256::from(3), 95555);
-        assert!(SubtensorModule::is_hotkey_registered_on_network(
-            netuid,
-            &U256::from(3)
-        ));
-        assert_eq!(SubtensorModule::get_subnetwork_n(netuid), 4);
-        step_block(1);
-
-        println!("+Registering: net:{:?}, cold:{:?}, hot:{:?}", netuid, 4, 4);
-        register_ok_neuron(netuid, U256::from(4), U256::from(4), 35555);
-        assert!(SubtensorModule::is_hotkey_registered_on_network(
-            netuid,
-            &U256::from(4)
-        ));
-        assert_eq!(SubtensorModule::get_subnetwork_n(netuid), 5);
-        step_block(1);
-
-        // Non self-weight fails.
-        let uids: Vec<u16> = vec![1, 2, 3, 4];
-        let values: Vec<u16> = vec![u16::MAX / 4, u16::MAX / 4, u16::MAX / 54, u16::MAX / 4];
-        let result = SubtensorModule::set_weights(
-            RuntimeOrigin::signed(U256::from(0)),
-            1.into(),
-            uids,
-            values,
-            0,
-        );
-        assert_eq!(result, Err(Error::<Test>::MaxWeightExceeded.into()));
-
-        // Self-weight is a success.
-        let uids: Vec<u16> = vec![0]; // Self.
-        let values: Vec<u16> = vec![u16::MAX]; // normalizes to u32::MAX
-        assert_ok!(SubtensorModule::set_weights(
-            RuntimeOrigin::signed(U256::from(0)),
-            1.into(),
-            uids,
-            values,
-            0
-        ));
-    });
-}
-
 // SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor --lib -- tests::weights::test_no_signature --exact --show-output --nocapture
 // Tests the call requires a valid origin.
 #[test]
@@ -1247,7 +1156,6 @@ fn test_set_weight_not_enough_values() {
         let neuron_uid: u16 = SubtensorModule::get_uid_for_net_and_hotkey(netuid, &U256::from(1))
             .expect("Not registered.");
         SubtensorModule::set_validator_permit_for_uid(netuid, neuron_uid, true);
-        SubtensorModule::set_max_weight_limit(netuid, u16::MAX);
         SubtensorModule::add_balance_to_coldkey_account(&U256::from(2), 1);
         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
             &account_id,
@@ -1313,8 +1221,6 @@ fn test_set_weight_too_many_uids() {
 
         register_ok_neuron(1.into(), U256::from(3), U256::from(4), 300_000);
         SubtensorModule::set_min_allowed_weights(1.into(), 2);
-        SubtensorModule::set_max_weight_limit(netuid, u16::MAX);
-
         // Should fail because we are setting more weights than there are neurons.
         let weight_keys: Vec<u16> = vec![0, 1, 2, 3, 4]; // more uids than neurons in subnet.
         let weight_values: Vec<u16> = vec![88, 102, 303, 1212, 11]; // random value.
@@ -1358,7 +1264,6 @@ fn test_set_weights_sum_larger_than_u16_max() {
             .expect("Not registered.");
         SubtensorModule::set_stake_threshold(0);
         SubtensorModule::set_validator_permit_for_uid(netuid, neuron_uid, true);
-        SubtensorModule::set_max_weight_limit(netuid, u16::MAX);
         SubtensorModule::add_balance_to_coldkey_account(&U256::from(2), 1);
         SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
             &(U256::from(1)),
@@ -1546,52 +1451,16 @@ fn test_max_weight_limited_when_weight_limit_is_u16_max() {
     });
 }
 
-// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor --lib -- tests::weights::test_max_weight_limited_when_max_weight_is_within_limit --exact --show-output --nocapture
-/// Check _truthy_ path for max weight limit
 #[test]
-fn test_max_weight_limited_when_max_weight_is_within_limit() {
+fn test_get_max_weight_limit_is_constant() {
     new_test_ext(0).execute_with(|| {
-        let max_allowed: u16 = 1;
-        let max_weight_limit = u16::MAX / 5;
-
-        let netuid = NetUid::from(1);
-        let uids: Vec<u16> = Vec::from_iter((0..max_allowed).map(|id| id + 1));
-        let uid: u16 = uids[0];
-        let weights: Vec<u16> = Vec::from_iter((0..max_allowed).map(|id| max_weight_limit - id));
-
-        SubtensorModule::set_max_weight_limit(netuid, max_weight_limit);
-
-        let expected = true;
-        let result = SubtensorModule::max_weight_limited(netuid, uid, &uids, &weights);
-
         assert_eq!(
-            expected, result,
-            "Failed get expected result when everything _should_ be fine"
+            SubtensorModule::get_max_weight_limit(NetUid::from(1)),
+            u16::MAX
         );
-    });
-}
-
-// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --package pallet-subtensor --lib -- tests::weights::test_max_weight_limited_when_guard_checks_are_not_triggered --exact --show-output --nocapture
-/// Check _falsey_ path
-#[test]
-fn test_max_weight_limited_when_guard_checks_are_not_triggered() {
-    new_test_ext(0).execute_with(|| {
-        let max_allowed: u16 = 3;
-        let max_weight_limit = u16::MAX / 5;
-
-        let netuid = NetUid::from(1);
-        let uids: Vec<u16> = Vec::from_iter((0..max_allowed).map(|id| id + 1));
-        let uid: u16 = uids[0];
-        let weights: Vec<u16> = Vec::from_iter((0..max_allowed).map(|id| max_weight_limit + id));
-
-        SubtensorModule::set_max_weight_limit(netuid, max_weight_limit);
-
-        let expected = false;
-        let result = SubtensorModule::max_weight_limited(netuid, uid, &uids, &weights);
-
         assert_eq!(
-            expected, result,
-            "Failed get expected result when guard-checks were not triggered"
+            SubtensorModule::get_max_weight_limit(NetUid::ROOT),
+            u16::MAX
         );
     });
 }
diff --git a/pallets/subtensor/src/utils/misc.rs b/pallets/subtensor/src/utils/misc.rs
index bb51eccd01..ee16b9aa01 100644
--- a/pallets/subtensor/src/utils/misc.rs
+++ b/pallets/subtensor/src/utils/misc.rs
@@ -549,12 +549,9 @@ impl<T: Config> Pallet<T> {
         Self::deposit_event(Event::ScalingLawPowerSet(netuid, scaling_law_power));
     }
 
-    pub fn get_max_weight_limit(netuid: NetUid) -> u16 {
-        MaxWeightsLimit::<T>::get(netuid)
-    }
-    pub fn set_max_weight_limit(netuid: NetUid, max_weight_limit: u16) {
-        MaxWeightsLimit::<T>::insert(netuid, max_weight_limit);
-        Self::deposit_event(Event::MaxWeightLimitSet(netuid, max_weight_limit));
+    #[inline(always)]
+    pub const fn get_max_weight_limit(_netuid: NetUid) -> u16 {
+        u16::MAX
     }
 
     pub fn get_immunity_period(netuid: NetUid) -> u16 {
diff --git a/pallets/transaction-fee/src/tests/mock.rs b/pallets/transaction-fee/src/tests/mock.rs
index 8e48c2e4fc..ee5b1693ba 100644
--- a/pallets/transaction-fee/src/tests/mock.rs
+++ b/pallets/transaction-fee/src/tests/mock.rs
@@ -142,7 +142,6 @@ impl pallet_transaction_payment::Config for Test {
 parameter_types! {
     pub const InitialMinAllowedWeights: u16 = 0;
     pub const InitialEmissionValue: u16 = 0;
-    pub const InitialMaxWeightsLimit: u16 = u16::MAX;
     pub BlockWeights: limits::BlockWeights = limits::BlockWeights::with_sensible_defaults(
         Weight::from_parts(2_000_000_000_000, u64::MAX),
         Perbill::from_percent(75),
@@ -227,7 +226,6 @@ impl pallet_subtensor::Config for Test {
     type Scheduler = Scheduler;
     type InitialMinAllowedWeights = InitialMinAllowedWeights;
     type InitialEmissionValue = InitialEmissionValue;
-    type InitialMaxWeightsLimit = InitialMaxWeightsLimit;
     type InitialTempo = InitialTempo;
     type InitialDifficulty = InitialDifficulty;
     type InitialAdjustmentInterval = InitialAdjustmentInterval;
diff --git a/precompiles/src/solidity/subnet.abi b/precompiles/src/solidity/subnet.abi
index f2d97e1f90..4531f59246 100644
--- a/precompiles/src/solidity/subnet.abi
+++ b/precompiles/src/solidity/subnet.abi
@@ -831,24 +831,6 @@
 		"stateMutability": "payable",
 		"type": "function"
 	},
-	{
-		"inputs": [
-			{
-				"internalType": "uint16",
-				"name": "netuid",
-				"type": "uint16"
-			},
-			{
-				"internalType": "uint16",
-				"name": "maxWeightLimit",
-				"type": "uint16"
-			}
-		],
-		"name": "setMaxWeightLimit",
-		"outputs": [],
-		"stateMutability": "payable",
-		"type": "function"
-	},
 	{
 		"inputs": [
 			{
diff --git a/precompiles/src/solidity/subnet.sol b/precompiles/src/solidity/subnet.sol
index 7517db3019..4e78708d62 100644
--- a/precompiles/src/solidity/subnet.sol
+++ b/precompiles/src/solidity/subnet.sol
@@ -75,11 +75,6 @@ interface ISubnet {
 
     function getMaxWeightLimit(uint16 netuid) external view returns (uint16);
 
-    function setMaxWeightLimit(
-        uint16 netuid,
-        uint16 maxWeightLimit
-    ) external payable;
-
     function getImmunityPeriod(uint16) external view returns (uint16);
 
     function setImmunityPeriod(
diff --git a/precompiles/src/subnet.rs b/precompiles/src/subnet.rs
index 8b4d0eff88..b7f5cdb098 100644
--- a/precompiles/src/subnet.rs
+++ b/precompiles/src/subnet.rs
@@ -290,27 +290,9 @@ where
     #[precompile::public("getMaxWeightLimit(uint16)")]
     #[precompile::view]
     fn get_max_weight_limit(_: &mut impl PrecompileHandle, netuid: u16) -> EvmResult<u16> {
-        Ok(pallet_subtensor::MaxWeightsLimit::<R>::get(NetUid::from(
-            netuid,
-        )))
-    }
-
-    #[precompile::public("setMaxWeightLimit(uint16,uint16)")]
-    #[precompile::payable]
-    fn set_max_weight_limit(
-        handle: &mut impl PrecompileHandle,
-        netuid: u16,
-        max_weight_limit: u16,
-    ) -> EvmResult<()> {
-        let call = pallet_admin_utils::Call::<R>::sudo_set_max_weight_limit {
-            netuid: netuid.into(),
-            max_weight_limit,
-        };
-
-        handle.try_dispatch_runtime_call::<R, _>(
-            call,
-            RawOrigin::Signed(handle.caller_account_id::<R>()),
-        )
+        Ok(pallet_subtensor::Pallet::<R>::get_max_weight_limit(
+            NetUid::from(netuid),
+        ))
     }
 
     #[precompile::public("getImmunityPeriod(uint16)")]
diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs
index 630140bfc9..b19b7ddf6f 100644
--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -683,9 +683,6 @@ impl InstanceFilter<RuntimeCall> for ProxyType {
                     | RuntimeCall::AdminUtils(
                         pallet_admin_utils::Call::sudo_set_adjustment_alpha { .. }
                     )
-                    | RuntimeCall::AdminUtils(
-                        pallet_admin_utils::Call::sudo_set_max_weight_limit { .. }
-                    )
                     | RuntimeCall::AdminUtils(
                         pallet_admin_utils::Call::sudo_set_immunity_period { .. }
                     )
@@ -980,7 +977,6 @@ parameter_types! {
     pub const SubtensorInitialIssuance: u64 = 0;
     pub const SubtensorInitialMinAllowedWeights: u16 = 1024;
     pub const SubtensorInitialEmissionValue: u16 = 0;
-    pub const SubtensorInitialMaxWeightsLimit: u16 = 1000; // 1000/2^16 = 0.015
     pub const SubtensorInitialValidatorPruneLen: u64 = 1;
     pub const SubtensorInitialScalingLawPower: u16 = 50; // 0.5
     pub const SubtensorInitialMaxAllowedValidators: u16 = 128;
@@ -1058,7 +1054,6 @@ impl pallet_subtensor::Config for Runtime {
     type InitialIssuance = SubtensorInitialIssuance;
     type InitialMinAllowedWeights = SubtensorInitialMinAllowedWeights;
     type InitialEmissionValue = SubtensorInitialEmissionValue;
-    type InitialMaxWeightsLimit = SubtensorInitialMaxWeightsLimit;
     type InitialValidatorPruneLen = SubtensorInitialValidatorPruneLen;
     type InitialScalingLawPower = SubtensorInitialScalingLawPower;
     type InitialTempo = SubtensorInitialTempo;