diff --git a/src/cmd_context/cmd_context.cpp b/src/cmd_context/cmd_context.cpp
index 8675365c9..c58453460 100644
--- a/src/cmd_context/cmd_context.cpp
+++ b/src/cmd_context/cmd_context.cpp
@@ -560,14 +560,6 @@ void cmd_context::set_produce_proofs(bool f) {
     m_params.m_proof = f;
 }
 
-void cmd_context::set_produce_interpolants(bool f) {
-    // can only be set before initialization
-    // FIXME currently synonym for produce_proofs
-    // also sets the default solver to be simple smt
-    SASSERT(!has_manager());
-    m_params.m_proof = f;
-    // set_solver_factory(mk_smt_solver_factory());
-}
 
 bool cmd_context::produce_models() const {
     return m_params.m_model;
@@ -577,11 +569,6 @@ bool cmd_context::produce_proofs() const {
     return m_params.m_proof;
 }
 
-bool cmd_context::produce_interpolants() const {
-    // FIXME currently synonym for produce_proofs
-    return m_params.m_proof;
-}
-
 bool cmd_context::produce_unsat_cores() const {
     return m_params.m_unsat_core;
 }
@@ -1895,25 +1882,14 @@ void cmd_context::validate_model() {
     }
 }
 
-// FIXME: really interpolants_enabled ought to be a parameter to the solver factory,
-// but this is a global change, so for now, we use an alternate solver factory
-// for interpolation
 
 void cmd_context::mk_solver() {
     bool proofs_enabled, models_enabled, unsat_core_enabled;
     params_ref p;
     m_params.get_solver_params(m(), p, proofs_enabled, models_enabled, unsat_core_enabled);
-    if (produce_interpolants() && m_interpolating_solver_factory) {
-        m_solver = (*m_interpolating_solver_factory)(m(), p, true /* must have proofs */, models_enabled, unsat_core_enabled, m_logic);
-    }
-    else
-        m_solver = (*m_solver_factory)(m(), p, proofs_enabled, models_enabled, unsat_core_enabled, m_logic);
+    m_solver = (*m_solver_factory)(m(), p, proofs_enabled, models_enabled, unsat_core_enabled, m_logic);
 }
 
-void cmd_context::set_interpolating_solver_factory(solver_factory * f) {
-  SASSERT(!has_manager());
-  m_interpolating_solver_factory   = f;
-}
 
 void cmd_context::set_solver_factory(solver_factory * f) {
     m_solver_factory   = f;
diff --git a/src/cmd_context/cmd_context.h b/src/cmd_context/cmd_context.h
index 124821561..226ec0480 100644
--- a/src/cmd_context/cmd_context.h
+++ b/src/cmd_context/cmd_context.h
@@ -342,14 +342,12 @@ public:
     void set_random_seed(unsigned s) { m_random_seed = s; }
     bool produce_models() const;
     bool produce_proofs() const;
-    bool produce_interpolants() const;
     bool produce_unsat_cores() const;
     bool well_sorted_check_enabled() const;
     bool validate_model_enabled() const;
     void set_produce_models(bool flag);
     void set_produce_unsat_cores(bool flag);
     void set_produce_proofs(bool flag);
-    void set_produce_interpolants(bool flag);
     void set_produce_unsat_assumptions(bool flag) { m_produce_unsat_assumptions = flag; }
     bool produce_assignments() const { return m_produce_assignments; }
     bool produce_unsat_assumptions() const { return m_produce_unsat_assumptions; }
@@ -365,7 +363,6 @@ public:
     sexpr_manager & sm() const { if (!m_sexpr_manager) const_cast<cmd_context*>(this)->m_sexpr_manager = alloc(sexpr_manager); return *m_sexpr_manager; }
 
     void set_solver_factory(solver_factory * s);
-    void set_interpolating_solver_factory(solver_factory * s);
     void set_check_sat_result(check_sat_result * r) { m_check_sat_result = r; }
     check_sat_result * get_check_sat_result() const { return m_check_sat_result.get(); }
     check_sat_state cs_state() const;
diff --git a/src/solver/parallel_tactic.cpp b/src/solver/parallel_tactic.cpp
index eda80b74b..d820dbd9b 100644
--- a/src/solver/parallel_tactic.cpp
+++ b/src/solver/parallel_tactic.cpp
@@ -391,10 +391,15 @@ private:
         log_branches(status);
     }
 
-    void report_sat(solver_state& s) {
+    void report_sat(solver_state& s, solver* conquer) {
         close_branch(s, l_true);
         model_ref mdl;
-        s.get_solver().get_model(mdl);
+        if (conquer) {
+            conquer->get_model(mdl);
+        }
+        else {
+            s.get_solver().get_model(mdl);
+        }
         if (mdl) {
             std::lock_guard<std::mutex> lock(m_mutex);
             if (&s.m() != &m_manager) {
@@ -453,7 +458,7 @@ private:
         if (canceled(s)) return;
         switch (s.simplify()) {
         case l_undef: break;
-        case l_true:  report_sat(s); return;
+        case l_true:  report_sat(s, nullptr); return;
         case l_false: report_unsat(s); return;                
         }
         if (canceled(s)) return;
@@ -498,7 +503,7 @@ private:
                 break;
 
             case l_true:
-                report_sat(s);
+                report_sat(s, conquer.get());
                 if (conquer) {
                     collect_statistics(*conquer.get());
                 }