Regarding Feit-Thompson Conjecture mentioned in Dave Benson's answer, which states that for any two distinct odd primes $p$ and $q$, the integer $\frac{p^q - 1}{p - 1}$ never divides $\frac{q^p - 1}{q - 1}$, I am unsure to what extent this has been verified. Below is a (parallelized) Python script that confirms the conjecture holds for $p, q < 50000$ within 35 hours. It also identifies the pair $(p, q) = (17,3313)$ as noted in JoshuaZ's comment, for the sole non-coprime example in this range. The range could be significantly improve by the method in this paper.

An other checking can be found in Guy's book (Unsolved Problems in Number Theory), at B25 on page 125:

Bonus question: Is there any other such pair in general?

Regarding Feit-Thompson Conjecture [FT62] mentioned in Dave Benson's answer, which states that for any two distinct odd primes $p$ and $q$, the integer $\frac{p^q - 1}{p - 1}$ never divides $\frac{q^p - 1}{q - 1}$, I am unsure to what extent this has been verified. Below is a (parallelized) Python script that confirms the conjecture holds for $p, q < 50000$ within 35 hours. It also identifies the pair $(p, q) = (17,3313)$, discovered in [S71], as noted in JoshuaZ's comment, for the sole non-coprime example in this range. The range could be significantly improved by the method in [S71].

Bonus question: Is there any other pair $(p,q)$ of this kind?

More recent checkings can be found in [G04] at B25 on page 125:

The last ckecking mentioned above is [DK04]. See also [M09].

References

[FT62] Feit, Walter; Thompson, John G. A solvability criterion for finite groups and some consequences. Proc. Nat. Acad. Sci. U.S.A. 48 (1962), 968--970.
[S71] Stephens, N. M. On the Feit-Thompson conjecture. Math. Comp. 25 (1971), 625.
[DK04] Dilcher, Karl; Knauer, Joshua. On a conjecture of Feit and Thompson. High primes and misdemeanours: lectures in honour of the 60th birthday of Hugh Cowie Williams, 169--178, Fields Inst. Commun., 41, Amer. Math. Soc., Providence, RI, 2004.
[G04] Guy, Richard K. Unsolved problems in number theory. Third edition. Problem Books in Mathematics. Springer-Verlag, New York, 2004. xviii+437 pp.
[M09] Motose, Kaoru. Notes on the Feit-Thompson conjecture. Proc. Japan Acad. Ser. A Math. Sci. 85 (2009), no. 2, 16--17.

Regarding Feit-Thompson Conjecture mentioned in Dave Benson's answer, which states that for any two distinct odd primes $p$ and $q$, the integer $\frac{p^q - 1}{p - 1}$ never divides $\frac{q^p - 1}{q - 1}$, I am unsure to what extent this has been verified. Below is a (parallelized) Python script that confirms the conjecture holds for $p, q < 25000$ within 90 minutes. It also identifies the pair $(p, q) = (17,3313)$ as noted in JoshuaZ's comment, for the sole non-coprime example in this range.

    ...$time python3 check_primes_parallel.py
Pair not relatively prime: p=17, q=3313, gcd=112643

real    88m57.158s
user    838m44.435s
sys 0m9.762s

# check_primes_parallel.py
from sympy import primerange, gcd
from multiprocessing import Pool
import itertools

def check_relative_prime_and_divisibility(pair):
    p, q = pair
    num1 = (pow(p, q) - 1) // (p - 1)
    num2 = (pow(q, p) - 1) // (q - 1)
    
    d = gcd(num1, num2)
    if d == 1:
        return None
    
    if num1 % num2 == 0:
        return f"Found divisible pair: p={p}, q={q}"
    else:
        return f"Pair not relatively prime: p={p}, q={q}, gcd={d}"

def find_prime_pairs(max_prime, num_cpus=12):
    # Generate a list of odd primes up to max_prime
    primes = list(primerange(3, max_prime))
    
    # Generate all unique combinations of two primes
    prime_pairs = list(itertools.combinations(primes, 2))

    # Create a pool of workers with the desired number of CPUs
    with Pool(processes=num_cpus) as pool:
        # Map the function over the prime pairs, distributed across the workers
        results = pool.map(check_relative_prime_and_divisibility, prime_pairs)
    
    # Filter out None results and print the rest
    for result in filter(None, results):
        print(result)

# Set a maximum prime number limit according to your computational power
max_prime = 25000 # You can adjust this value
find_prime_pairs(max_prime)

Regarding Feit-Thompson Conjecture mentioned in Dave Benson's answer, which states that for any two distinct odd primes $p$ and $q$, the integer $\frac{p^q - 1}{p - 1}$ never divides $\frac{q^p - 1}{q - 1}$, I am unsure to what extent this has been verified. Below is a (parallelized) Python script that confirms the conjecture holds for $p, q < 50000$ within 35 hours. It also identifies the pair $(p, q) = (17,3313)$ as noted in JoshuaZ's comment, for the sole non-coprime example in this range. The range could be significantly improve by the method in this paper.

An other checking can be found in Guy's book (Unsolved Problems in Number Theory), at B25 on page 125:

Bonus question: Is there any other such pair in general?

    ...$time python3 check_primes_parallel.py
Pair not relatively prime: p=17, q=3313, gcd=112643

real    2066m4.640s
user    13490m17.916s
sys 1m1.613s

# check_primes_parallel.py
from sympy import primerange, gcd
from multiprocessing import Pool
import itertools

def check_relative_prime_and_divisibility(pair):
    p, q = pair
    num1 = (pow(p, q) - 1) // (p - 1)
    num2 = (pow(q, p) - 1) // (q - 1)
    
    d = gcd(num1, num2)
    if d == 1:
        return None
    
    if num1 % num2 == 0:
        return f"Found divisible pair: p={p}, q={q}"
    else:
        return f"Pair not relatively prime: p={p}, q={q}, gcd={d}"

def find_prime_pairs(max_prime, num_cpus=8):
    # Generate a list of odd primes up to max_prime
    primes = list(primerange(3, max_prime))
    
    # Generate all unique combinations of two primes
    prime_pairs = list(itertools.combinations(primes, 2))

    # Create a pool of workers with the desired number of CPUs
    with Pool(processes=num_cpus) as pool:
        # Map the function over the prime pairs, distributed across the workers
        results = pool.map(check_relative_prime_and_divisibility, prime_pairs)
    
    # Filter out None results and print the rest
    for result in filter(None, results):
        print(result)

# Set a maximum prime number limit according to your computational power
max_prime = 50000 # You can adjust this value
find_prime_pairs(max_prime)

Regarding the conjecture mentioned in Dave Benson's answer, which states that for any two distinct odd primes $p$ and $q$, the integer $\frac{q^p - 1}{q - 1}$ never divides $\frac{p^q - 1}{p - 1}$, I am unsure to what extent this has been verified. Below is a Python script that confirms the conjecture holds for $p, q < 5000$ within 2 minutes. It also identifies the pair $(p, q) = (3313,17)$ as noted in JoshuaZ's comment, for the sole non-coprime example in this range.

...$time python3 check_primes.py
Pair not relatively prime: p=3313, q=17, gcd=112643

real    2m5.001s
user    2m4.981s
sys 0m0.012s

# check_primes.py
from sympy import primerange, gcd

def check_relative_prime_and_divisibility(p, q):
    # Calculate the expressions (p^q - 1)/(p - 1) and (q^p - 1)/(q - 1)
    num1 = (pow(p, q) - 1) // (p - 1)
    num2 = (pow(q, p) - 1) // (q - 1)
    
    # Check if num1 and num2 are relatively prime
    d = gcd(num1, num2)
    if d == 1:
        return False
    
    # If they are not relatively prime, check divisibility
    print(f"Pair not relatively prime: p={p}, q={q}, gcd={d}")
    return num2 % num1 == 0

def find_prime_pairs(max_prime):
    # Generate a list of odd primes up to max_prime
    primes = list(primerange(3, max_prime))
    
    # Iterate over all pairs of odd primes p, q where p > q
    for i in range(len(primes)):
        p = primes[i]
        #print(p)
        for j in range(i):
            q = primes[j]
            if check_relative_prime_and_divisibility(p, q):
                print(f"Found divisible pair: p={p}, q={q}")

# Set a maximum prime number limit according to your laptop's computational power
max_prime = 5000 # You can adjust this value
find_prime_pairs(max_prime)

Regarding Feit-Thompson Conjecture mentioned in Dave Benson's answer, which states that for any two distinct odd primes $p$ and $q$, the integer $\frac{p^q - 1}{p - 1}$ never divides $\frac{q^p - 1}{q - 1}$, I am unsure to what extent this has been verified. Below is a (parallelized) Python script that confirms the conjecture holds for $p, q < 25000$ within 90 minutes. It also identifies the pair $(p, q) = (17,3313)$ as noted in JoshuaZ's comment, for the sole non-coprime example in this range.

    ...$time python3 check_primes_parallel.py
Pair not relatively prime: p=17, q=3313, gcd=112643

real    88m57.158s
user    838m44.435s
sys 0m9.762s

# check_primes_parallel.py
from sympy import primerange, gcd
from multiprocessing import Pool
import itertools

def check_relative_prime_and_divisibility(pair):
    p, q = pair
    num1 = (pow(p, q) - 1) // (p - 1)
    num2 = (pow(q, p) - 1) // (q - 1)
    
    d = gcd(num1, num2)
    if d == 1:
        return None
    
    if num1 % num2 == 0:
        return f"Found divisible pair: p={p}, q={q}"
    else:
        return f"Pair not relatively prime: p={p}, q={q}, gcd={d}"

def find_prime_pairs(max_prime, num_cpus=12):
    # Generate a list of odd primes up to max_prime
    primes = list(primerange(3, max_prime))
    
    # Generate all unique combinations of two primes
    prime_pairs = list(itertools.combinations(primes, 2)) 

    # Create a pool of workers with the desired number of CPUs
    with Pool(processes=num_cpus) as pool:
        # Map the function over the prime pairs, distributed across the workers
        results = pool.map(check_relative_prime_and_divisibility, prime_pairs)
     
    # Filter out None results and print the rest
    for result in filter(None, results):
        print(result)

# Set a maximum prime number limit according to your computational power
max_prime = 25000 # You can adjust this value
find_prime_pairs(max_prime)