diff --git a/src/proto_alpha/lib_protocol/delegate_sampler.ml b/src/proto_alpha/lib_protocol/delegate_sampler.ml
index a3801233c9e67e725f720f14717a5509305713aa..9ea36b58ec1cb608b20cd62011c063ea4da371b8 100644
--- a/src/proto_alpha/lib_protocol/delegate_sampler.ml
+++ b/src/proto_alpha/lib_protocol/delegate_sampler.ml
@@ -166,20 +166,20 @@ let get_delegate_stake_from_staking_balance ctxt delegate staking_balance =
   Lwt.return
     (Stake_context.apply_limits ctxt staking_parameters staking_balance)
 
-let get_stakes_for_selected_index ctxt ~slashings index =
+let get_stakes_for_selected_index ctxt ~slashings:_ _index =
   let open Lwt_result_syntax in
   let minimal_frozen_stake = Constants_storage.minimal_frozen_stake ctxt in
   let minimal_stake = Constants_storage.minimal_stake ctxt in
-  Stake_storage.fold_snapshot
+  Stake_storage.fold_on_active_delegates_with_minimal_stake_es
     ctxt
-    ~index
-    ~f:(fun (delegate, staking_balance) acc ->
-      let staking_balance =
-        match Signature.Public_key_hash.Map.find delegate slashings with
-        | None -> staking_balance
-        | Some percentage ->
-            Full_staking_balance_repr.apply_slashing ~percentage staking_balance
+    ~order:`Sorted
+    ~f:(fun delegate acc ->
+      let* staking_balance =
+        Stake_storage.get_full_staking_balance ctxt delegate
       in
+      (* This function is called after slashing has been applied at cycle end,
+         hence there is no need to apply slashing on [staking_balance] as it
+         used to be when the value was taken from a snapshot. *)
       if
         Full_staking_balance_repr.has_minimal_frozen_stake
           ~minimal_frozen_stake
diff --git a/src/proto_alpha/lib_protocol/full_staking_balance_repr.ml b/src/proto_alpha/lib_protocol/full_staking_balance_repr.ml
index f697fecbd933ae73ffa49aebc4179d46c59bf1ae..086550d862dd836b5969028fb044a13f68027eda 100644
--- a/src/proto_alpha/lib_protocol/full_staking_balance_repr.ml
+++ b/src/proto_alpha/lib_protocol/full_staking_balance_repr.ml
@@ -9,30 +9,81 @@ type t = {
   own_frozen : Tez_repr.t;
   staked_frozen : Tez_repr.t;
   delegated : Tez_repr.t;
+  min_delegated_in_cycle : Tez_repr.t;
+  cycle_of_min_delegated : Cycle_repr.t;
 }
 
-let init ~own_frozen ~staked_frozen ~delegated =
-  {own_frozen; staked_frozen; delegated}
+let init ~own_frozen ~staked_frozen ~delegated ~current_cycle =
+  {
+    own_frozen;
+    staked_frozen;
+    delegated;
+    min_delegated_in_cycle = delegated;
+    cycle_of_min_delegated = current_cycle;
+  }
 
 let encoding =
   let open Data_encoding in
+  (* This encoding is backward-compatible with the encoding used in Oxford, so
+     as to avoid a stitching in P. It will act as a lazy migration.
+     The case in which [added_in_p] is [None] happen only for pre-existing
+     values in the storage. For them, using [(delegated, Cycle_repr.root)]
+     should behave correctly. *)
+  let added_in_p =
+    obj2
+      (req "min_delegated_in_cycle" Tez_repr.encoding)
+      (req "cycle_of_min_delegated" Cycle_repr.encoding)
+  in
   conv
-    (fun {own_frozen; staked_frozen; delegated} ->
-      (own_frozen, staked_frozen, delegated))
-    (fun (own_frozen, staked_frozen, delegated) ->
-      {own_frozen; staked_frozen; delegated})
-    (obj3
+    (fun {
+           own_frozen;
+           staked_frozen;
+           delegated;
+           min_delegated_in_cycle;
+           cycle_of_min_delegated;
+         } ->
+      ( own_frozen,
+        staked_frozen,
+        delegated,
+        Some (min_delegated_in_cycle, cycle_of_min_delegated) ))
+    (fun (own_frozen, staked_frozen, delegated, added_in_p_opt) ->
+      let min_delegated_in_cycle, cycle_of_min_delegated =
+        added_in_p_opt |> Option.value ~default:(delegated, Cycle_repr.root)
+      in
+      {
+        own_frozen;
+        staked_frozen;
+        delegated;
+        min_delegated_in_cycle;
+        cycle_of_min_delegated;
+      })
+    (obj4
        (req "own_frozen" Tez_repr.encoding)
        (req "staked_frozen" Tez_repr.encoding)
-       (req "delegated" Tez_repr.encoding))
+       (req "delegated" Tez_repr.encoding)
+       (varopt "min_delegated_in_cycle_and_cycle" added_in_p))
 
-let voting_weight {own_frozen; staked_frozen; delegated} =
+let voting_weight
+    {
+      own_frozen;
+      staked_frozen;
+      delegated;
+      min_delegated_in_cycle = _;
+      cycle_of_min_delegated = _;
+    } =
   let open Result_syntax in
   let* frozen = Tez_repr.(own_frozen +? staked_frozen) in
   let+ all = Tez_repr.(frozen +? delegated) in
   Tez_repr.to_mutez all
 
-let apply_slashing ~percentage {own_frozen; staked_frozen; delegated} =
+let apply_slashing ~percentage
+    {
+      own_frozen;
+      staked_frozen;
+      delegated;
+      min_delegated_in_cycle;
+      cycle_of_min_delegated;
+    } =
   let remaining_percentage = Int_percentage.neg percentage in
   let own_frozen =
     Tez_repr.mul_percentage ~rounding:`Down own_frozen remaining_percentage
@@ -40,23 +91,92 @@ let apply_slashing ~percentage {own_frozen; staked_frozen; delegated} =
   let staked_frozen =
     Tez_repr.mul_percentage ~rounding:`Down staked_frozen remaining_percentage
   in
-  {own_frozen; staked_frozen; delegated}
+  {
+    own_frozen;
+    staked_frozen;
+    delegated;
+    min_delegated_in_cycle;
+    cycle_of_min_delegated;
+  }
 
-let own_frozen {own_frozen; staked_frozen = _; delegated = _} = own_frozen
+let own_frozen
+    {
+      own_frozen;
+      staked_frozen = _;
+      delegated = _;
+      min_delegated_in_cycle = _;
+      cycle_of_min_delegated = _;
+    } =
+  own_frozen
 
-let staked_frozen {own_frozen = _; staked_frozen; delegated = _} = staked_frozen
+let staked_frozen
+    {
+      own_frozen = _;
+      staked_frozen;
+      delegated = _;
+      min_delegated_in_cycle = _;
+      cycle_of_min_delegated = _;
+    } =
+  staked_frozen
 
-let total_frozen {own_frozen; staked_frozen; delegated = _} =
+let total_frozen
+    {
+      own_frozen;
+      staked_frozen;
+      delegated = _;
+      min_delegated_in_cycle = _;
+      cycle_of_min_delegated = _;
+    } =
   Tez_repr.(own_frozen +? staked_frozen)
 
-let delegated {own_frozen = _; staked_frozen = _; delegated} = delegated
+let current_delegated
+    {
+      own_frozen = _;
+      staked_frozen = _;
+      delegated;
+      min_delegated_in_cycle = _;
+      cycle_of_min_delegated = _;
+    } =
+  delegated
+
+(* The minimum over the cycle is either:
+     - the current delegated value if it didn't change during the cycle, i.e.
+       [cycle_of_min_delegated] is not the current cycle;
+     - or the stored [min_delegated_in_cycle] otherwise.
+*)
+let min_delegated_in_cycle ~current_cycle
+    {
+      own_frozen = _;
+      staked_frozen = _;
+      delegated;
+      min_delegated_in_cycle;
+      cycle_of_min_delegated;
+    } =
+  if Cycle_repr.(cycle_of_min_delegated < current_cycle) then delegated
+  else (
+    assert (Cycle_repr.(cycle_of_min_delegated = current_cycle)) ;
+    min_delegated_in_cycle)
 
-let total {own_frozen; staked_frozen; delegated} =
+let current_total
+    {
+      own_frozen;
+      staked_frozen;
+      delegated;
+      min_delegated_in_cycle = _;
+      cycle_of_min_delegated = _;
+    } =
   let open Result_syntax in
   let* total_frozen = Tez_repr.(own_frozen +? staked_frozen) in
   Tez_repr.(total_frozen +? delegated)
 
-let own_ratio {own_frozen; staked_frozen; delegated = _} =
+let own_ratio
+    {
+      own_frozen;
+      staked_frozen;
+      delegated = _;
+      min_delegated_in_cycle = _;
+      cycle_of_min_delegated = _;
+    } =
   if Tez_repr.(staked_frozen = zero) then (1L, 1L)
   else if Tez_repr.(own_frozen = zero) then (0L, 1L)
   else
@@ -64,43 +184,141 @@ let own_ratio {own_frozen; staked_frozen; delegated = _} =
     let staked_frozen = Tez_repr.to_mutez staked_frozen in
     (own_frozen, Int64.add own_frozen staked_frozen)
 
-let has_minimal_frozen_stake ~minimal_frozen_stake
-    {own_frozen; staked_frozen = _; delegated = _} =
+let has_minimal_frozen_stake ~minimal_frozen_stake full_staking_balance =
+  let own_frozen = own_frozen full_staking_balance in
   Tez_repr.(own_frozen >= minimal_frozen_stake)
 
+(* The set of delegates to consider [Active_delegates_with_minimal_stake] is an
+   over-approximation of participating delegates. It is maintained by
+   {!Stake_storage}.
+   To avoid having to do any maintenance at cycle end, we have to rely on values
+   that do not change when crossing cycle boundaries: the current amount works,
+   the minimal in a given cycle wouldn't. *)
 let has_minimal_stake_to_be_considered ~minimal_stake full_staking_balance =
-  match total full_staking_balance with
+  match current_total full_staking_balance with
   | Error _total_overflows ->
       true
       (* If the total overflows, we are definitely over the minimal stake. *)
   | Ok staking_balance -> Tez_repr.(staking_balance >= minimal_stake)
 
-let remove_delegated ~amount {own_frozen; staked_frozen; delegated} =
+let remove_delegated ~current_cycle ~amount
+    {
+      own_frozen;
+      staked_frozen;
+      delegated;
+      min_delegated_in_cycle;
+      cycle_of_min_delegated;
+    } =
   let open Result_syntax in
   let+ delegated = Tez_repr.(delegated -? amount) in
-  {own_frozen; staked_frozen; delegated}
+  let min_delegated_in_cycle =
+    if Cycle_repr.(cycle_of_min_delegated < current_cycle) then
+      (* after decrease *) delegated
+    else (
+      assert (Cycle_repr.(cycle_of_min_delegated = current_cycle)) ;
+      Tez_repr.min delegated min_delegated_in_cycle)
+  in
+  {
+    own_frozen;
+    staked_frozen;
+    delegated;
+    min_delegated_in_cycle;
+    cycle_of_min_delegated = current_cycle;
+  }
 
-let remove_own_frozen ~amount {own_frozen; staked_frozen; delegated} =
+let remove_own_frozen ~amount
+    {
+      own_frozen;
+      staked_frozen;
+      delegated;
+      min_delegated_in_cycle;
+      cycle_of_min_delegated;
+    } =
   let open Result_syntax in
   let+ own_frozen = Tez_repr.(own_frozen -? amount) in
-  {own_frozen; staked_frozen; delegated}
+  {
+    own_frozen;
+    staked_frozen;
+    delegated;
+    min_delegated_in_cycle;
+    cycle_of_min_delegated;
+  }
 
-let remove_staked_frozen ~amount {own_frozen; staked_frozen; delegated} =
+let remove_staked_frozen ~amount
+    {
+      own_frozen;
+      staked_frozen;
+      delegated;
+      min_delegated_in_cycle;
+      cycle_of_min_delegated;
+    } =
   let open Result_syntax in
   let+ staked_frozen = Tez_repr.(staked_frozen -? amount) in
-  {own_frozen; staked_frozen; delegated}
+  {
+    own_frozen;
+    staked_frozen;
+    delegated;
+    min_delegated_in_cycle;
+    cycle_of_min_delegated;
+  }
 
-let add_delegated ~amount {own_frozen; staked_frozen; delegated} =
+let add_delegated ~current_cycle ~amount
+    {
+      own_frozen;
+      staked_frozen;
+      delegated;
+      min_delegated_in_cycle;
+      cycle_of_min_delegated;
+    } =
   let open Result_syntax in
+  let min_delegated_in_cycle =
+    if Cycle_repr.(cycle_of_min_delegated < current_cycle) then
+      (* before increase *) delegated
+    else (
+      assert (Cycle_repr.(cycle_of_min_delegated = current_cycle)) ;
+      min_delegated_in_cycle)
+  in
   let+ delegated = Tez_repr.(delegated +? amount) in
-  {own_frozen; staked_frozen; delegated}
+  {
+    own_frozen;
+    staked_frozen;
+    delegated;
+    min_delegated_in_cycle;
+    cycle_of_min_delegated = current_cycle;
+  }
 
-let add_own_frozen ~amount {own_frozen; staked_frozen; delegated} =
+let add_own_frozen ~amount
+    {
+      own_frozen;
+      staked_frozen;
+      delegated;
+      min_delegated_in_cycle;
+      cycle_of_min_delegated;
+    } =
   let open Result_syntax in
   let+ own_frozen = Tez_repr.(own_frozen +? amount) in
-  {own_frozen; staked_frozen; delegated}
+  {
+    own_frozen;
+    staked_frozen;
+    delegated;
+    min_delegated_in_cycle;
+    cycle_of_min_delegated;
+  }
 
-let add_staked_frozen ~amount {own_frozen; staked_frozen; delegated} =
+let add_staked_frozen ~amount
+    {
+      own_frozen;
+      staked_frozen;
+      delegated;
+      min_delegated_in_cycle;
+      cycle_of_min_delegated;
+    } =
   let open Result_syntax in
   let+ staked_frozen = Tez_repr.(staked_frozen +? amount) in
-  {own_frozen; staked_frozen; delegated}
+  {
+    own_frozen;
+    staked_frozen;
+    delegated;
+    min_delegated_in_cycle;
+    cycle_of_min_delegated;
+  }
diff --git a/src/proto_alpha/lib_protocol/full_staking_balance_repr.mli b/src/proto_alpha/lib_protocol/full_staking_balance_repr.mli
index ac49289e14a3a946290796da3b1937b6470239ff..ef2ac998922606bcda5caa8779c67d323f7c1f7b 100644
--- a/src/proto_alpha/lib_protocol/full_staking_balance_repr.mli
+++ b/src/proto_alpha/lib_protocol/full_staking_balance_repr.mli
@@ -8,7 +8,11 @@
 type t
 
 val init :
-  own_frozen:Tez_repr.t -> staked_frozen:Tez_repr.t -> delegated:Tez_repr.t -> t
+  own_frozen:Tez_repr.t ->
+  staked_frozen:Tez_repr.t ->
+  delegated:Tez_repr.t ->
+  current_cycle:Cycle_repr.t ->
+  t
 
 val encoding : t Data_encoding.t
 
@@ -21,13 +25,15 @@ val own_frozen : t -> Tez_repr.t
 
 val staked_frozen : t -> Tez_repr.t
 
-val delegated : t -> Tez_repr.t
+val current_delegated : t -> Tez_repr.t
+
+val min_delegated_in_cycle : current_cycle:Cycle_repr.t -> t -> Tez_repr.t
 
 (** Sum of [own_frozen] and [staked_frozen]. *)
 val total_frozen : t -> Tez_repr.t tzresult
 
-(** Sum of [own_frozen], [staked_frozen], and [delegated]. *)
-val total : t -> Tez_repr.t tzresult
+(** Sum of [own_frozen], [staked_frozen], and [current_delegated]. *)
+val current_total : t -> Tez_repr.t tzresult
 
 (** [own_ratio full_staking_balance] returns [(num, den)] representing the
 ratio of [own_frozen] over [total_frozen] for [full_staking_balance].
@@ -38,13 +44,15 @@ val has_minimal_frozen_stake : minimal_frozen_stake:Tez_repr.t -> t -> bool
 
 val has_minimal_stake_to_be_considered : minimal_stake:Tez_repr.t -> t -> bool
 
-val remove_delegated : amount:Tez_repr.t -> t -> t tzresult
+val remove_delegated :
+  current_cycle:Cycle_repr.t -> amount:Tez_repr.t -> t -> t tzresult
 
 val remove_own_frozen : amount:Tez_repr.t -> t -> t tzresult
 
 val remove_staked_frozen : amount:Tez_repr.t -> t -> t tzresult
 
-val add_delegated : amount:Tez_repr.t -> t -> t tzresult
+val add_delegated :
+  current_cycle:Cycle_repr.t -> amount:Tez_repr.t -> t -> t tzresult
 
 val add_own_frozen : amount:Tez_repr.t -> t -> t tzresult
 
diff --git a/src/proto_alpha/lib_protocol/stake_context.ml b/src/proto_alpha/lib_protocol/stake_context.ml
index 4cbe0b84c1982de46c56deb343ed7287ebdba11d..a65ab5fb42bb0e5cbf41b6868a1a956885f59337 100644
--- a/src/proto_alpha/lib_protocol/stake_context.ml
+++ b/src/proto_alpha/lib_protocol/stake_context.ml
@@ -25,9 +25,14 @@
 
 let apply_limits ctxt staking_parameters staking_balance =
   let open Result_syntax in
+  let current_cycle = (Raw_context.current_level ctxt).cycle in
   let own_frozen = Full_staking_balance_repr.own_frozen staking_balance in
   let staked_frozen = Full_staking_balance_repr.staked_frozen staking_balance in
-  let delegated = Full_staking_balance_repr.delegated staking_balance in
+  let delegated =
+    Full_staking_balance_repr.min_delegated_in_cycle
+      ~current_cycle
+      staking_balance
+  in
   let limit_of_delegation_over_baking =
     Int64.of_int (Constants_storage.limit_of_delegation_over_baking ctxt)
   in
@@ -63,7 +68,10 @@ let apply_limits ctxt staking_parameters staking_balance =
         Tez_repr.min staked_frozen max_allowed_staked_frozen
     | Error _max_allowed_staked_frozen_overflows -> staked_frozen
   in
-  (* Overstaked tez count as delegated. *)
+  (* Overstaked tez count as delegated.
+     Note that, unlike delegated tez, overstaked tez may not have been staked
+     the whole cycle to contribute to rights, but they are going to be frozen
+     for several cycles. *)
   let* overstaked = Tez_repr.(staked_frozen -? allowed_staked_frozen) in
   let* delegated = Tez_repr.(delegated +? overstaked) in
   (* Overdelegated tez don't count. *)
@@ -97,7 +105,9 @@ let optimal_frozen_wrt_delegated_without_ai ctxt full_staking_balance =
 
      With AI the optimum is to freeze as much as possible, this computation
      would make no sense. *)
-  let delegated = Full_staking_balance_repr.delegated full_staking_balance in
+  let delegated =
+    Full_staking_balance_repr.current_delegated full_staking_balance
+  in
   let own_frozen = Full_staking_balance_repr.own_frozen full_staking_balance in
   let* power = Tez_repr.(delegated +? own_frozen) in
   let* opti_frozen =
diff --git a/src/proto_alpha/lib_protocol/stake_storage.ml b/src/proto_alpha/lib_protocol/stake_storage.ml
index 8ecb2d81188d6abf652fa50b44414259f9dd28f1..d181d05d064e6c4a23e6cf3b97b3729490650973 100644
--- a/src/proto_alpha/lib_protocol/stake_storage.ml
+++ b/src/proto_alpha/lib_protocol/stake_storage.ml
@@ -83,11 +83,13 @@ let has_minimal_stake ctxt staking_balance =
 
 let initialize_delegate ctxt delegate ~delegated =
   let open Lwt_result_syntax in
+  let current_cycle = (Raw_context.current_level ctxt).cycle in
   let balance =
     Full_staking_balance_repr.init
       ~own_frozen:Tez_repr.zero
       ~staked_frozen:Tez_repr.zero
       ~delegated
+      ~current_cycle
   in
   let* ctxt = Storage.Stake.Staking_balance.init ctxt delegate balance in
   if has_minimal_stake ctxt balance then
@@ -139,7 +141,8 @@ let update_stake ~f ctxt delegate =
   | false, false | true, true -> return ctxt
 
 let remove_delegated_stake ctxt delegate amount =
-  let f = Full_staking_balance_repr.remove_delegated ~amount in
+  let current_cycle = (Raw_context.current_level ctxt).cycle in
+  let f = Full_staking_balance_repr.remove_delegated ~current_cycle ~amount in
   update_stake ctxt delegate ~f
 
 let remove_own_frozen_stake ctxt delegate amount =
@@ -158,7 +161,8 @@ let remove_frozen_stake_only_call_from_token ctxt staker amount =
       remove_staked_frozen_stake ctxt delegate amount
 
 let add_delegated_stake ctxt delegate amount =
-  let f = Full_staking_balance_repr.add_delegated ~amount in
+  let current_cycle = (Raw_context.current_level ctxt).cycle in
+  let f = Full_staking_balance_repr.add_delegated ~current_cycle ~amount in
   update_stake ctxt delegate ~f
 
 let add_own_frozen_stake ctxt delegate amount =
@@ -290,7 +294,7 @@ module For_RPC = struct
   let get_staking_balance ctxt delegate =
     let open Lwt_result_syntax in
     let* staking_balance = Storage.Stake.Staking_balance.get ctxt delegate in
-    Lwt.return (Full_staking_balance_repr.total staking_balance)
+    Lwt.return (Full_staking_balance_repr.current_total staking_balance)
 end
 
 module Internal_for_tests = struct
diff --git a/src/proto_alpha/lib_protocol/test/helpers/adaptive_issuance_helpers.ml b/src/proto_alpha/lib_protocol/test/helpers/adaptive_issuance_helpers.ml
index 35e8d135225995c773c25b125dce63487cf6da25..c4c97f770f24b42d80392958af3897e543cb25c9 100644
--- a/src/proto_alpha/lib_protocol/test/helpers/adaptive_issuance_helpers.ml
+++ b/src/proto_alpha/lib_protocol/test/helpers/adaptive_issuance_helpers.ml
@@ -1107,28 +1107,6 @@ let apply_slashing
       culprit_name
       account_map
   in
-  let update_frozen_rights_with_slash ({frozen_rights; _} as acc) =
-    let cycle_to_slash =
-      Cycle.add current_cycle (constants.preserved_cycles + 1)
-    in
-    let frozen_rights =
-      CycleMap.update
-        cycle_to_slash
-        (function
-          | None -> None
-          | Some x ->
-              Some
-                (Tez.mul_q
-                   x
-                   Q.((Protocol.Int_percentage.neg slashed_pct :> int) // 100)
-                |> Tez.of_q ~round_up:false))
-        frozen_rights
-    in
-    {acc with frozen_rights}
-  in
-  let account_map =
-    update_account ~f:update_frozen_rights_with_slash culprit_name account_map
-  in
   let total_after_slash = get_total_supply account_map in
   let portion_reward =
     constants.adaptive_issuance.global_limit_of_staking_over_baking + 2
diff --git a/src/proto_alpha/lib_protocol/test/integration/test_adaptive_issuance_roundtrip.ml b/src/proto_alpha/lib_protocol/test/integration/test_adaptive_issuance_roundtrip.ml
index 2f78f44d5ba96832162cd554edea153690aac783..d3a487e4319ab4f0c6032fcf9291910a4cb10e7a 100644
--- a/src/proto_alpha/lib_protocol/test/integration/test_adaptive_issuance_roundtrip.ml
+++ b/src/proto_alpha/lib_protocol/test/integration/test_adaptive_issuance_roundtrip.ml
@@ -564,6 +564,8 @@ module State = struct
     let* launch_cycle_opt =
       Context.get_adaptive_issuance_launch_cycle (B block)
     in
+    (* Apply all slashes *)
+    let state = apply_all_slashes_at_cycle_end current_cycle state in
     (* Sets initial frozen for future cycle *)
     let state =
       update_map
@@ -572,9 +574,6 @@ module State = struct
              (Cycle.add current_cycle (state.constants.preserved_cycles + 1)))
         state
     in
-    (* Apply all slashes. They also apply to the frozen rights computed above,
-       for "reasons" related to snapshoting and the way slashes are applied to it *)
-    let state = apply_all_slashes_at_cycle_end current_cycle state in
     (* Apply autostaking *)
     let*?@ state =
       if not state.constants.adaptive_issuance.autostaking_enable then Ok state
@@ -1794,7 +1793,7 @@ let test_expected_error =
            (exec (fun _ -> failwith "")))
 
 let init_constants ?reward_per_block ?(deactivate_dynamic = false)
-    ?blocks_per_cycle ?(force_snapshot_at_end = false) ~autostaking_enable () =
+    ?blocks_per_cycle ~autostaking_enable () =
   let reward_per_block = Option.value ~default:0L reward_per_block in
   let base_total_issued_per_minute = Tez.of_mutez reward_per_block in
   let default_constants = Default_parameters.constants_test in
@@ -1802,10 +1801,6 @@ let init_constants ?reward_per_block ?(deactivate_dynamic = false)
   let blocks_per_cycle =
     Option.value ~default:default_constants.blocks_per_cycle blocks_per_cycle
   in
-  let blocks_per_stake_snapshot =
-    if force_snapshot_at_end then blocks_per_cycle
-    else default_constants.blocks_per_stake_snapshot
-  in
   let issuance_weights =
     Protocol.Alpha_context.Constants.Parametric.
       {
@@ -1842,7 +1837,6 @@ let init_constants ?reward_per_block ?(deactivate_dynamic = false)
     cost_per_byte;
     adaptive_issuance;
     blocks_per_cycle;
-    blocks_per_stake_snapshot;
   }
 
 (** Initialization of scenarios with 3 cases:
@@ -2561,11 +2555,7 @@ module Slashing = struct
   let test_slash_monotonous_stake =
     let scenario ~op ~early_d =
       let constants =
-        init_constants
-          ~force_snapshot_at_end:true
-          ~blocks_per_cycle:8l
-          ~autostaking_enable:false
-          ()
+        init_constants ~blocks_per_cycle:8l ~autostaking_enable:false ()
       in
       begin_test ~activate_ai:false constants ["delegate"]
       --> next_cycle
@@ -2589,11 +2579,7 @@ module Slashing = struct
 
   let test_slash_timing =
     let constants =
-      init_constants
-        ~force_snapshot_at_end:true
-        ~blocks_per_cycle:8l
-        ~autostaking_enable:false
-        ()
+      init_constants ~blocks_per_cycle:8l ~autostaking_enable:false ()
     in
     begin_test ~activate_ai:false constants ["delegate"]
     --> next_cycle
@@ -2610,9 +2596,7 @@ module Slashing = struct
     --> double_bake "delegate" --> make_denunciations () --> next_cycle
 
   let init_scenario_with_delegators delegate_name faucet_name delegators_list =
-    let constants =
-      init_constants ~force_snapshot_at_end:true ~autostaking_enable:false ()
-    in
+    let constants = init_constants ~autostaking_enable:false () in
     let rec init_delegators = function
       | [] -> Empty
       | (delegator, amount) :: t ->
diff --git a/tezt/tests/expected/consensus_key.ml/Alpha- Test drain delegate with (baker - delegate - consensus - destination).out b/tezt/tests/expected/consensus_key.ml/Alpha- Test drain delegate with (baker - delegate - consensus - destination).out
index f7a7f47956fdea013a0d37c93613544da3264e0e..e066f38f2334459476cf333ed1a04264cb6e8c09 100644
--- a/tezt/tests/expected/consensus_key.ml/Alpha- Test drain delegate with (baker - delegate - consensus - destination).out	
+++ b/tezt/tests/expected/consensus_key.ml/Alpha- Test drain delegate with (baker - delegate - consensus - destination).out	
@@ -96,7 +96,7 @@ This sequence of operations was run:
 
 ./octez-client rpc get '/chains/main/blocks/head/context/delegates/[PUBLIC_KEY_HASH]'
 { "full_balance": "238000528932", "current_frozen_deposits": "200000181573",
-  "frozen_deposits": "200000057423", "staking_balance": "238000528932",
+  "frozen_deposits": "200000083984", "staking_balance": "238000528932",
   "delegated_contracts": [ "[PUBLIC_KEY_HASH]" ],
   "delegated_balance": "0", "deactivated": false, "grace_period": 4,
   "total_delegated_stake": "0", "staking_denominator": "0",
diff --git a/tezt/tests/expected/consensus_key.ml/Alpha- Test drain delegate with (baker - delegate - consensus -- destination).out b/tezt/tests/expected/consensus_key.ml/Alpha- Test drain delegate with (baker - delegate - consensus -- destination).out
index 3c0dd49e9877d2199862f2aa6dfc8bdb66ee223f..892b917c3981b6ee50e880c0c2ae83f029ec39e5 100644
--- a/tezt/tests/expected/consensus_key.ml/Alpha- Test drain delegate with (baker - delegate - consensus -- destination).out	
+++ b/tezt/tests/expected/consensus_key.ml/Alpha- Test drain delegate with (baker - delegate - consensus -- destination).out	
@@ -96,7 +96,7 @@ This sequence of operations was run:
 
 ./octez-client rpc get '/chains/main/blocks/head/context/delegates/[PUBLIC_KEY_HASH]'
 { "full_balance": "238000528932", "current_frozen_deposits": "200000181573",
-  "frozen_deposits": "200000057423", "staking_balance": "238000528932",
+  "frozen_deposits": "200000083984", "staking_balance": "238000528932",
   "delegated_contracts": [ "[PUBLIC_KEY_HASH]" ],
   "delegated_balance": "0", "deactivated": false, "grace_period": 4,
   "total_delegated_stake": "0", "staking_denominator": "0",
diff --git a/tezt/tests/expected/consensus_key.ml/Alpha- Test drain delegate with (baker -- delegate - consensus - destination).out b/tezt/tests/expected/consensus_key.ml/Alpha- Test drain delegate with (baker -- delegate - consensus - destination).out
index f5ee491b8bbc68ed1d400a2f9f0bc2f8f6388bb1..f7aefc6ee837e21300c4bc8caac2890774559fe8 100644
--- a/tezt/tests/expected/consensus_key.ml/Alpha- Test drain delegate with (baker -- delegate - consensus - destination).out	
+++ b/tezt/tests/expected/consensus_key.ml/Alpha- Test drain delegate with (baker -- delegate - consensus - destination).out	
@@ -96,7 +96,7 @@ This sequence of operations was run:
 
 ./octez-client rpc get '/chains/main/blocks/head/context/delegates/[PUBLIC_KEY_HASH]'
 { "full_balance": "238000509096", "current_frozen_deposits": "200000164892",
-  "frozen_deposits": "200000040756", "staking_balance": "238000509096",
+  "frozen_deposits": "200000067317", "staking_balance": "238000509096",
   "delegated_contracts": [ "[PUBLIC_KEY_HASH]" ],
   "delegated_balance": "0", "deactivated": false, "grace_period": 4,
   "total_delegated_stake": "0", "staking_denominator": "0",
diff --git a/tezt/tests/expected/consensus_key.ml/Alpha- Test drain delegate with (baker -- delegate - consensus -- destination).out b/tezt/tests/expected/consensus_key.ml/Alpha- Test drain delegate with (baker -- delegate - consensus -- destination).out
index e6ebc6b6aa3a3f436df320f23fb802028935c30b..1e092ea539b08eb868db979038e16f1d63300ba9 100644
--- a/tezt/tests/expected/consensus_key.ml/Alpha- Test drain delegate with (baker -- delegate - consensus -- destination).out	
+++ b/tezt/tests/expected/consensus_key.ml/Alpha- Test drain delegate with (baker -- delegate - consensus -- destination).out	
@@ -96,7 +96,7 @@ This sequence of operations was run:
 
 ./octez-client rpc get '/chains/main/blocks/head/context/delegates/[PUBLIC_KEY_HASH]'
 { "full_balance": "238000509096", "current_frozen_deposits": "200000164892",
-  "frozen_deposits": "200000040756", "staking_balance": "238000509096",
+  "frozen_deposits": "200000067317", "staking_balance": "238000509096",
   "delegated_contracts": [ "[PUBLIC_KEY_HASH]" ],
   "delegated_balance": "0", "deactivated": false, "grace_period": 4,
   "total_delegated_stake": "0", "staking_denominator": "0",