Polygon to Sphere using the SAT algorithm

Question

I have been trying to get Sphere to Polygon collision to work for a long time now but I am having problems with the edge cases.

In 2D the axis for the edge detection that you use for the projection can be just this:

axis = new Vector3(-edge.Y, edge.X);

But this doesn't work in 3D, and here is where I am stuck.. I have tried using the polygon's face normals and use the cross prudoct with an edge but that didn't work, I also tried some diffrent combinations for the axis and using another combination when the polygon is infront the sphere but that still didn't help.. there is always an area where it detects a collision even though they are not colliding.

This is the area where it shouldn't detect a collision: https://imgur.com/a/fESaGwL

Any other areas like here works just fine: https://imgur.com/a/lBpTYiz

This is my code so far (I have the faces and vertices cases commented because they weren't the problem):

       public static bool PolygonToSphere(Vector3 polyCenter, Vector3 sphCenter, Vector3[] polyVerts, int[] polyInds, float radius, out Vector3 iNormal, out float iDepth) {
            iNormal = Vector3.Zero;
            iDepth = float.MaxValue;

            Vector3 axis;
            float axisDepth;

            float minA, maxA, minB, maxB;

            Vector3 dir = polyCenter - sphCenter;

            /*#region Faces ...*/

            #region Edges
            for (int i = 0; i < polyInds.Length - 1; i++) {
                Vector3 p1 = polyVerts[polyInds[i]];
                Vector3 p2 = polyVerts[polyInds[i + 1]];

                axis = p2 - p1;
                axis = new Vector3(-axis.Y, axis.X, -axis.Z);

                if (Vector3.Dot(axis, dir) < 0f) {
                    axis.NormalizeFast();
                } else {
                    axis = p2 - p1;
                    axis = new Vector3(axis.X, axis.Z, -axis.Y);
                    axis.NormalizeFast();
                }

                ProjectVertices(polyVerts, axis, out minA, out maxA);
                ProjectSphere(sphCenter, radius, axis, out minB, out maxB);

                if (minA > maxB || minB > maxA) {
                    return false;
                }

                axisDepth = MathHelper.Min(maxB - minA, maxA - minB);
                if (axisDepth < iDepth) {
                    iDepth = axisDepth;
                    iNormal = axis;
                }
            }
            #endregion

            /*#region Vertices ...*/
            

            if (Vector3.Dot(iNormal, dir) < 0f) {
                iNormal = -iNormal;
            }
            

            return true;
        }

        private static void ProjectVertices(Vector3[] vertices, Vector3 axis, out float min, out float max) {
            min = float.MaxValue;
            max = float.MinValue;

            for (int i = 0; i < vertices.Length; i++) {
                Vector3 v = vertices[i];
                float proj = Vector3.Dot(v, axis);

                if (proj < min) { min = proj; }
                if (proj > max) { max = proj; }
            }
        }
        private static void ProjectSphere(Vector3 center, float radius, Vector3 axis, out float min, out float max) {
            min = Vector3.Dot(center, axis) - radius;
            max = Vector3.Dot(center, axis) + radius;

            if (min > max) {
                float t = min;
                min = max;
                max = t;
            }
        }