Client certificate has different thumprint via ARR and AuthorizationContext

I am currently working on a prototype for a WCF service that will make use of client-certificate authentication. We would like to be able to directly publish our application to IIS, but also allow SSL offloading using IIS ARR (Application Request Routing).

After digging through the documentation, I have been able to test both configurations successfully. I am able to retrieve the client certificate used to authenticate from:

1. X-Arr-ClientCert - the header that contains the certificate when using ARR.
2. X509CertificateClaimSet - when published directly to IIS, this is how to retrieve the Client Certificate

To verify that the request is allowed, I match the thumbprint of the certificate to the expected thumbprint that is configured somewhere. To my surprise, when getting the certificate through different methods, the same certificate has different thumbprints.

To verify what is going on, I have converted the "RawData" property on both certificates to Base64 and found that it's the same, except that in the case of the X509CertificateClaimSet, there are spaces in the certificate data, while in the case of ARR, there are not. Otherwise, both strings are the same:

My question: Has anyone else run into this, and can I actually rely on thumbprints? If not, my backup plan is to implement a check on Subject and Issuer, but I am open to other suggestions.

I have included some (simplified) sample code below:

  string expectedThumbprint = "...";
  if (OperationContext.Current.ServiceSecurityContext == null ||
    OperationContext.Current.ServiceSecurityContext.AuthorizationContext.ClaimSets == null ||
    OperationContext.Current.ServiceSecurityContext.AuthorizationContext.ClaimSets.Count <= 0)
  {
    // Claimsets not found, assume that we are reverse proxied by ARR (Application Request Routing). If this is the case, we expect the certificate to be in the X-ARR-CLIENTCERT header
    IncomingWebRequestContext request = WebOperationContext.Current.IncomingRequest;
    string certBase64 = request.Headers["X-Arr-ClientCert"];
    if (certBase64 == null) return false;
    byte[] bytes = Convert.FromBase64String(certBase64);
    var cert = new System.Security.Cryptography.X509Certificates.X509Certificate2(bytes);
    return cert.Thumbprint == expectedThumbprint;
  }
  // In this case, we are directly published to IIS with Certificate authentication.
  else 
  {
    bool correctCertificateFound = false;
    foreach (var claimSet in OperationContext.Current.ServiceSecurityContext.AuthorizationContext.ClaimSets)
    {
      if (!(claimSet is X509CertificateClaimSet)) continue;
      var cert = ((X509CertificateClaimSet)claimSet).X509Certificate;
      // Match certificate thumbprint to expected value
      if (cert.Thumbprint == expectedThumbprint)
      {
        correctCertificateFound = true;
        break;
      }
    }
    return correctCertificateFound;
  }

When setting up the test again for a peer review by colleagues, it appears that my issue has gone away. I'm not sure if I made a mistake (probably) or if rebooting my machine helped, but in any case, the Thumbprint now is reliable over both methods of authentication.