diff --git a/gap/perm.gi b/gap/perm.gi
index d92017998..60e6dae00 100644
--- a/gap/perm.gi
+++ b/gap/perm.gi
@@ -347,24 +347,39 @@ end;
 #! @BeginChunk ThrowAwayFixedPoints
 #! This method defines a homomorphism of a permutation group
 #! <A>G</A> to the action on the moved points of <A>G</A> if
-#! <A>G</A> does not have too many moved points. In the current setup, the
-#! homomorphism is defined if the number <M>k</M> of moved
+#! either <A>G</A> has a lot of fixed points, or if <A>G</A> knows that it is
+#! primitive and has fixed points. If <A>G</A> does not know whether it is
+#! primitive and has fixed points, then it returns <K>NotEnoughInformation</K>
+#! so that it may be called again at a later time.
+#! In all other cases, it returns <K>NeverApplicable</K>.
+#! <P/>
+#!
+#! In the current setup, the
+#! homomorphism is defined if the number <M>n</M> of moved
 #! points is at most <M>1/3</M> of the largest moved point of <A>G</A>,
-#! or  <M>k</M> is at most half of the number of points on which
-#! <A>G</A> is stored internally by &GAP;. The method returns
-#! <K>NeverApplicable</K> if it does not define a homomorphism indicating that it will
-#! never succeed.
+#! or  <M>n</M> is at most half of the number of points on which
+#! <A>G</A> is stored internally by &GAP;.
 #! @EndChunk
 FindHomMethodsPerm.ThrowAwayFixedPoints :=
   function( ri, G )
       # Check, whether we can throw away fixed points
-      local gens,hom,l,n,o;
+      local gens,nrStoredPoints,n,largest,isApplicable,o,hom;
 
       gens := GeneratorsOfGroup(G);
-      l := List(gens,StoredPointsPerm);
+      nrStoredPoints := Maximum(List(gens,StoredPointsPerm));
       n := NrMovedPoints(G);
-      if 2*n > Maximum(l) or 3*n > LargestMovedPoint(G) then  # we do nothing
-          return NeverApplicable;
+      largest := LargestMovedPoint(G);
+      # If isApplicable is true, we definitely are applicable.
+      isApplicable := 3*n <= largest or 2*n <= nrStoredPoints
+        or (HasIsPrimitive(G) and IsPrimitive(G) and n < largest);
+      # If isApplicable is false, we might become applicable if G figures out
+      # that it is primitive.
+      if not isApplicable then
+          if not HasIsPrimitive(G) and n < largest then
+              return NotEnoughInformation;
+          else
+              return NeverApplicable;
+          fi;
       fi;
       o := MovedPoints(G);
       hom := ActionHomomorphism(G,o);
diff --git a/gap/perm/largebase.gi b/gap/perm/largebase.gi
index cf854f525..2d690320f 100644
--- a/gap/perm/largebase.gi
+++ b/gap/perm/largebase.gi
@@ -507,6 +507,14 @@ end;
 #! <M>r \cdot k > 1</M>
 #! and <M>2 \cdot r \cdot k^2 \le n</M>.
 #!
+#! A large primitive group <M>H</M>of the above type which does have fixed
+#! points is handled as follows.  After a call of <C>LargeBasePrimitive</C>,
+#! the group <M>H</M> knows that it is primitive. Thus, after
+#! LargeBasePrimitive returns <K>NeverApplicable</K>, the function
+#! <Ref Func="ThrowAwayFixedPoints"/> will prune away the fixed points and set
+#! up a homomorphism. <C>LargeBasePrimitive</C> is then applicable to the image
+#! of that homomorphism.
+#!
 #! If <A>G</A> is imprimitive then the output is
 #! <K>NeverApplicable</K>. If <A>G</A> is primitive then
 #! the output is either a homomorphism into the
@@ -526,6 +534,7 @@ FindHomMethodsPerm.LargeBasePrimitive :=
     fi;
     RECOG.SetPseudoRandomStamp(grp,"Jellyfish");
     res := RECOG.AllJellyfish(grp);
+    RECOG.SetPseudoRandomStamp(grp,"PseudoRandom");
     if res = NeverApplicable or res = TemporaryFailure then
         return res;
     fi;
diff --git a/tst/working/quick/PermLargeBasePrimitive.tst b/tst/working/quick/PermLargeBasePrimitive.tst
index fed7adf6c..6eb02d382 100644
--- a/tst/working/quick/PermLargeBasePrimitive.tst
+++ b/tst/working/quick/PermLargeBasePrimitive.tst
@@ -1,4 +1,5 @@
 #@local S19OnSets, jellyGroup, n, random, jellyGroupConj, ri
+#@local addFixedPointsPerm, jellyGroupWithFixedPoints, riWithFixed
 
 # Test for LargeBasePrimitive
 gap> S19OnSets := Action(SymmetricGroup(19), Combinations([1 .. 19], 2), OnSets);;
@@ -7,7 +8,22 @@ gap> n := NrMovedPoints(jellyGroup);;
 gap> # Take a random conjugate
 gap> random := Random(SymmetricGroup(n));;
 gap> jellyGroupConj := jellyGroup ^ random;;
-gap> RECOG.TestGroup(jellyGroupConj,
+gap> ri := RECOG.TestGroup(jellyGroupConj,
 >   false,
 >   Size(jellyGroup),
 >   rec(tryNonGroupElements := true));;
+gap> ri!.fhmethsel.successMethod;
+"LargeBasePrimitive"
+
+# Test that groups with fixed points are handled together by
+# ThrowAwayFixedPoints and LargeBasePrimitive.
+gap> addFixedPointsPerm := Random(SymmetricGroup(5 * QuoInt(n,2)));;
+gap> jellyGroupWithFixedPoints := jellyGroup ^ addFixedPointsPerm;;
+gap> riWithFixed := RECOG.TestGroup(jellyGroupWithFixedPoints,
+>   false,
+>   Size(jellyGroup),
+>   rec(tryNonGroupElements := true));;
+gap> riWithFixed!.fhmethsel.successMethod;
+"ThrowAwayFixedPoints"
+gap> RIFac(riWithFixed)!.fhmethsel.successMethod;
+"LargeBasePrimitive"