Returned Integer from Function Not Working with -eq Operator

I've got the following function that will export a registry key and will return 0 for success and 1 for failure. When I attempt to compare the result using -eq 0, the compare fails when the function returns 0. I've even tried casting both the return # and $ExportResult to [System.Int32], however that didn't work. Any ideas?

Function Export-Registry{
    param(
	    [String]$Path
    )

    $ModifiedPath = $Path -replace "HKEY_CURRENT_USER", "HKCU" -replace "HKEY_LOCAL_MACHINE", "HKLM" -replace "HKCU:", "HKCU" -replace "HKLM:", "HKLM"

    try{
	    Start-ProcessStdOutput -File "Reg" -Arguments "export `"$($ModifiedPath)`" `"$($RegBackupLocationPath)\WinHttp_Settings.reg`" /Y "
    }catch{
	    Write-CLog $_.Exception.Message -Category 'Exception' -Source 'Reg'
    }

    if (Test-Path -Path "$($RegBackupLocationPath)\WinHttp_Settings.reg"){
	    Write-CLog "Registry exported successfully." -Source "Info" -Category "Export-Registry"
	    return 0
    }else{
	    Write-CLog "Registry export failed" -Source "ERROR" -Category "Export-Registry"
	    return 1
    }
}

This is the check:

$ExportResult = Export-Registry -Path $RegBackupKey
if ($ExportResult -eq 0){
    #do stuff
}else{
    #registry export failed
}

Get-Member -InputObject $ExportResult output:

 TypeName: System.Object[]

Name           MemberType            Definition                                                                        
----           ----------            ----------                                                                        
Count          AliasProperty         Count = Length                                                                    
Add            Method                int IList.Add(System.Object value)                                                
Address        Method                System.Object&, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a...
Clear          Method                void IList.Clear()                                                                
Clone          Method                System.Object Clone(), 
System.Object ICloneable.Clone()                           
CompareTo      Method                int 
IStructuralComparable.CompareTo(System.Object other, System.Collections.ICo...
Contains       Method                bool IList.Contains(System.Object value)                                          
CopyTo         Method                void CopyTo(array array, int index), void CopyTo(array array, long index), void...Equals         Method                bool Equals(System.Object obj), bool 
IStructuralEquatable.Equals(System.Object ...
Get            Method                System.Object Get(int )                                                           
GetEnumerator  Method                System.Collections.IEnumerator 
GetEnumerator(), System.Collections.IEnumerator ...
GetHashCode    Method                int GetHashCode(), int IStructuralEquatable.GetHashCode(System.Collections.IEqu...
GetLength      Method                int GetLength(int dimension)                                                      
GetLongLength  Method                long GetLongLength(int dimension)                                                 
GetLowerBound  Method                int GetLowerBound(int dimension)                                                  
GetType        Method                type GetType()                                                                    
GetUpperBound  Method                int GetUpperBound(int dimension)                                                  
GetValue       Method                System.Object GetValue(Params int[] indices), System.Object GetValue(int index)...
IndexOf        Method                int IList.IndexOf(System.Object value)                                            
Initialize     Method                void Initialize()                                                                 
Insert         Method                void IList.Insert(int index, System.Object value)                                 
Remove         Method                void IList.Remove(System.Object value)                                            
RemoveAt       Method                void IList.RemoveAt(int index)                                                    
Set            Method                void Set(int , System.Object )                                                    
SetValue       Method                void SetValue(System.Object value, int index), void SetValue(System.Object valu...
ToString       Method                string ToString()                                                                 
Item           ParameterizedProperty System.Object IList.Item(int index) {get;set;}                                    
IsFixedSize    Property              bool IsFixedSize {get;}                                                           
IsReadOnly     Property              bool IsReadOnly {get;}                                                            
IsSynchronized Property              bool IsSynchronized {get;}                                                        
Length         Property              int Length {get;}                                                                 
LongLength     Property              long LongLength {get;}                                                            
Rank           Property              int Rank {get;}                                                                   
SyncRoot       Property              System.Object SyncRoot {get;}           

Answer is, one of your custom functions, either Start-ProcessStdOutput or Write-CLog (presumably the former) is writing to the Success Stream (stdout) thus becoming part of your function's output which is why you are getting an object[] instead of int32 as output type.

In consequence, the comparison $ExportResult -eq 0 fails because some comparison operators (-eq being one of them) can act as filters when there is a collection on the left-hand side of the comparison, i.e:

$foo = 0..10
$foo -eq 0 # outputs `0` instead of a boolean

And then 0 when coerced to a boolean becomes $false. See about Booleans for details:

$foo = 0..10
[bool] ($foo -eq 0) # becomes `$false`

Same happens in the context of an if condition:

$foo = 0..10
if($foo -eq 0) { 'foo' } # produces no output

Solution to your problem is to either capture or redirect the output from your custom functions, or write to a different stream from them, i.e. verbose or information streams (Write-Verbose or Write-Host so that your function only outputs an int32).