diff --git a/opm/simulators/wells/WellInterface.hpp b/opm/simulators/wells/WellInterface.hpp
index 6e7b2ea12..2b070a64a 100644
--- a/opm/simulators/wells/WellInterface.hpp
+++ b/opm/simulators/wells/WellInterface.hpp
@@ -263,6 +263,13 @@ public:
 
     void checkWellOperability(const Simulator& ebos_simulator, const WellState& well_state, DeferredLogger& deferred_logger);
 
+    bool gliftBeginTimeStepWellTestIterateWellEquations(
+        const Simulator& ebos_simulator,
+        const double dt,
+        WellState& well_state,
+        const GroupState &group_state,
+        DeferredLogger& deferred_logger);
+
     void gliftBeginTimeStepWellTestUpdateALQ(const Simulator& ebos_simulator,
                                              WellState& well_state,
                                              DeferredLogger& deferred_logger);
diff --git a/opm/simulators/wells/WellInterface_impl.hpp b/opm/simulators/wells/WellInterface_impl.hpp
index dc9af269f..42cee8c80 100644
--- a/opm/simulators/wells/WellInterface_impl.hpp
+++ b/opm/simulators/wells/WellInterface_impl.hpp
@@ -382,12 +382,16 @@ namespace Opm
         const double dt = ebosSimulator.timeStepSize();
         const auto& summary_state = ebosSimulator.vanguard().summaryState();
         const bool has_thp_limit = this->wellHasTHPConstraints(summary_state);
-        if (has_thp_limit)
+        bool converged;
+        if (has_thp_limit) {
             well_state.well(this->indexOfWell()).production_cmode = Well::ProducerCMode::THP;
-        else
+            converged = gliftBeginTimeStepWellTestIterateWellEquations(
+                ebosSimulator, dt, well_state, group_state, deferred_logger);
+        }
+        else {
             well_state.well(this->indexOfWell()).production_cmode = Well::ProducerCMode::BHP;
-
-        const bool converged = iterateWellEquations(ebosSimulator, dt, well_state, group_state, deferred_logger);
+            converged = iterateWellEquations(ebosSimulator, dt, well_state, group_state, deferred_logger);
+        }
         if (converged) {
             deferred_logger.debug("WellTest: Well equation for well " + this->name() +  " converged");
             return true;
@@ -584,6 +588,38 @@ namespace Opm
         }
     }
 
+    template<typename TypeTag>
+    bool
+    WellInterface<TypeTag>::
+    gliftBeginTimeStepWellTestIterateWellEquations(
+        const Simulator& ebos_simulator,
+        const double dt,
+        WellState& well_state,
+        const GroupState &group_state,
+        DeferredLogger& deferred_logger)
+    {
+        const auto& well_name = this->name();
+        const auto& summary_state = ebos_simulator.vanguard().summaryState();
+        assert(this->wellHasTHPConstraints(summary_state));
+        const auto& schedule = ebos_simulator.vanguard().schedule();
+        auto report_step_idx = ebos_simulator.episodeIndex();
+        const auto& glo = schedule.glo(report_step_idx);
+        assert(glo.has_well(well_name));
+        auto increment = glo.gaslift_increment();
+        auto alq = well_state.getALQ(well_name);
+        bool converged;
+        while (alq > 0) {
+            well_state.setALQ(well_name, alq);
+            if ((converged =
+                  iterateWellEquations(ebos_simulator, dt, well_state, group_state, deferred_logger)))
+            {
+                return converged;
+            }
+            alq -= increment;
+        }
+        return false;
+    }
+
     template<typename TypeTag>
     void
     WellInterface<TypeTag>::