fetch_openml fails on leukemia

### Describe the bug

Downloading leukemia dataset with `fetch_openml` fails

Visiting the link causing the tiemout https://openml.org/api/v1/json/data/list/data_name/leukemia/limit/2/status/active/ redirects me to 
https://old.openml.org/api/v1/json/data/list/data_name/leukemia/limit/2/status/active/ which works fine

### Steps/Code to Reproduce

```python
from sklearn.datasets import fetch_openml
fetch_openml("leukemia", data_home='inexistant_path')
```

### Expected Results

dataset downloaded 

### Actual Results



download fails :

<details> 
   
```python
  home/mathurin/anaconda3/lib/python3.9/site-packages/sklearn/datasets/_openml.py:91: UserWarning: A network error occurred while downloading https://openml.org/api/v1/json/data/list/data_name/leukemia/limit/2/status/active/. Retrying...
    warn(
  ---------------------------------------------------------------------------
  timeout                                   Traceback (most recent call last)
  File ~/anaconda3/lib/python3.9/urllib/request.py:1346, in AbstractHTTPHandler.do_open(self, http_class, req, **http_conn_args)
     1345 try:
  -> 1346     h.request(req.get_method(), req.selector, req.data, headers,
     1347               encode_chunked=req.has_header('Transfer-encoding'))
     1348 except OSError as err: # timeout error
  
  File ~/anaconda3/lib/python3.9/http/client.py:1279, in HTTPConnection.request(self, method, url, body, headers, encode_chunked)
     1278 """Send a complete request to the server."""
  -> 1279 self._send_request(method, url, body, headers, encode_chunked)
  
  File ~/anaconda3/lib/python3.9/http/client.py:1325, in HTTPConnection._send_request(self, method, url, body, headers, encode_chunked)
     1324     body = _encode(body, 'body')
  -> 1325 self.endheaders(body, encode_chunked=encode_chunked)
  
  File ~/anaconda3/lib/python3.9/http/client.py:1274, in HTTPConnection.endheaders(self, message_body, encode_chunked)
     1273     raise CannotSendHeader()
  -> 1274 self._send_output(message_body, encode_chunked=encode_chunked)
  
  File ~/anaconda3/lib/python3.9/http/client.py:1034, in HTTPConnection._send_output(self, message_body, encode_chunked)
     1033 del self._buffer[:]
  -> 1034 self.send(msg)
     1036 if message_body is not None:
     1037 
     1038     # create a consistent interface to message_body
  
  File ~/anaconda3/lib/python3.9/http/client.py:974, in HTTPConnection.send(self, data)
      973 if self.auto_open:
  --> 974     self.connect()
      975 else:
  
  File ~/anaconda3/lib/python3.9/http/client.py:1448, in HTTPSConnection.connect(self)
     1446     server_hostname = self.host
  -> 1448 self.sock = self._context.wrap_socket(self.sock,
     1449                                       server_hostname=server_hostname)
  
  File ~/anaconda3/lib/python3.9/ssl.py:500, in SSLContext.wrap_socket(self, sock, server_side, do_handshake_on_connect, suppress_ragged_eofs, server_hostname, session)
      494 def wrap_socket(self, sock, server_side=False,
      495                 do_handshake_on_connect=True,
      496                 suppress_ragged_eofs=True,
      497                 server_hostname=None, session=None):
      498     # SSLSocket class handles server_hostname encoding before it calls
      499     # ctx._wrap_socket()
  --> 500     return self.sslsocket_class._create(
      501         sock=sock,
      502         server_side=server_side,
      503         do_handshake_on_connect=do_handshake_on_connect,
      504         suppress_ragged_eofs=suppress_ragged_eofs,
      505         server_hostname=server_hostname,
      506         context=self,
      507         session=session
      508     )
  
  File ~/anaconda3/lib/python3.9/ssl.py:1040, in SSLSocket._create(cls, sock, server_side, do_handshake_on_connect, suppress_ragged_eofs, server_hostname, context, session)
     1039             raise ValueError("do_handshake_on_connect should not be specified for non-blocking sockets")
  -> 1040         self.do_handshake()
     1041 except (OSError, ValueError):
  
  File ~/anaconda3/lib/python3.9/ssl.py:1309, in SSLSocket.do_handshake(self, block)
     1308         self.settimeout(None)
  -> 1309     self._sslobj.do_handshake()
     1310 finally:
  
  timeout: _ssl.c:1112: The handshake operation timed out
  
  During handling of the above exception, another exception occurred:
  
  URLError                                  Traceback (most recent call last)
  Input In [6], in <module>
  ----> 1 fetch_openml("leukemia", data_home='inexistant_path')
  
  File ~/anaconda3/lib/python3.9/site-packages/sklearn/datasets/_openml.py:746, in fetch_openml(name, version, data_id, data_home, target_column, cache, return_X_y, as_frame, n_retries, delay)
      740     if data_id is not None:
      741         raise ValueError(
      742             "Dataset data_id={} and name={} passed, but you can only "
      743             "specify a numeric data_id or a name, not "
      744             "both.".format(data_id, name)
      745         )
  --> 746     data_info = _get_data_info_by_name(
      747         name, version, data_home, n_retries=n_retries, delay=delay
      748     )
      749     data_id = data_info["did"]
      750 elif data_id is not None:
      751     # from the previous if statement, it is given that name is None
  
  File ~/anaconda3/lib/python3.9/site-packages/sklearn/datasets/_openml.py:285, in _get_data_info_by_name(name, version, data_home, n_retries, delay)
      283 url = _SEARCH_NAME.format(name) + "/status/active/"
      284 error_msg = "No active dataset {} found.".format(name)
  --> 285 json_data = _get_json_content_from_openml_api(
      286     url,
      287     error_msg,
      288     data_home=data_home,
      289     n_retries=n_retries,
      290     delay=delay,
      291 )
      292 res = json_data["data"]["dataset"]
      293 if len(res) > 1:
  
  File ~/anaconda3/lib/python3.9/site-packages/sklearn/datasets/_openml.py:229, in _get_json_content_from_openml_api(url, error_message, data_home, n_retries, delay)
      226         return json.loads(response.read().decode("utf-8"))
      228 try:
  --> 229     return _load_json()
      230 except HTTPError as error:
      231     # 412 is an OpenML specific error code, indicating a generic error
      232     # (e.g., data not found)
      233     if error.code != 412:
  
  File ~/anaconda3/lib/python3.9/site-packages/sklearn/datasets/_openml.py:52, in _retry_with_clean_cache.<locals>.decorator.<locals>.wrapper(*args, **kw)
       50     return f(*args, **kw)
       51 try:
  ---> 52     return f(*args, **kw)
       53 except URLError:
       54     raise
  
  File ~/anaconda3/lib/python3.9/site-packages/sklearn/datasets/_openml.py:224, in _get_json_content_from_openml_api.<locals>._load_json()
      221 @_retry_with_clean_cache(url, data_home)
      222 def _load_json():
      223     with closing(
  --> 224         _open_openml_url(url, data_home, n_retries=n_retries, delay=delay)
      225     ) as response:
      226         return json.loads(response.read().decode("utf-8"))
  
  File ~/anaconda3/lib/python3.9/site-packages/sklearn/datasets/_openml.py:156, in _open_openml_url(openml_path, data_home, n_retries, delay)
      149 try:
      150     # Create a tmpdir as a subfolder of dir_name where the final file will
      151     # be moved to if the download is successful. This guarantees that the
      152     # renaming operation to the final location is atomic to ensure the
      153     # concurrence safety of the dataset caching mechanism.
      154     with TemporaryDirectory(dir=dir_name) as tmpdir:
      155         with closing(
  --> 156             _retry_on_network_error(n_retries, delay, req.full_url)(urlopen)(
      157                 req, timeout=delay
      158             )
      159         ) as fsrc:
      160             opener: Callable
      161             if is_gzip_encoded(fsrc):
  
  File ~/anaconda3/lib/python3.9/site-packages/sklearn/datasets/_openml.py:84, in _retry_on_network_error.<locals>.decorator.<locals>.wrapper(*args, **kwargs)
       82 while True:
       83     try:
  ---> 84         return f(*args, **kwargs)
       85     except (URLError, TimeoutError) as e:
       86         # 412 is a specific OpenML error code.
       87         if isinstance(e, HTTPError) and e.code == 412:
  
  File ~/anaconda3/lib/python3.9/urllib/request.py:214, in urlopen(url, data, timeout, cafile, capath, cadefault, context)
      212 else:
      213     opener = _opener
  --> 214 return opener.open(url, data, timeout)
  
  File ~/anaconda3/lib/python3.9/urllib/request.py:517, in OpenerDirector.open(self, fullurl, data, timeout)
      514     req = meth(req)
      516 sys.audit('urllib.Request', req.full_url, req.data, req.headers, req.get_method())
  --> 517 response = self._open(req, data)
      519 # post-process response
      520 meth_name = protocol+"_response"
  
  File ~/anaconda3/lib/python3.9/urllib/request.py:534, in OpenerDirector._open(self, req, data)
      531     return result
      533 protocol = req.type
  --> 534 result = self._call_chain(self.handle_open, protocol, protocol +
      535                           '_open', req)
      536 if result:
      537     return result
  
  File ~/anaconda3/lib/python3.9/urllib/request.py:494, in OpenerDirector._call_chain(self, chain, kind, meth_name, *args)
      492 for handler in handlers:
      493     func = getattr(handler, meth_name)
  --> 494     result = func(*args)
      495     if result is not None:
      496         return result
  
  File ~/anaconda3/lib/python3.9/urllib/request.py:1389, in HTTPSHandler.https_open(self, req)
     1388 def https_open(self, req):
  -> 1389     return self.do_open(http.client.HTTPSConnection, req,
     1390         context=self._context, check_hostname=self._check_hostname)
  
  File ~/anaconda3/lib/python3.9/urllib/request.py:1349, in AbstractHTTPHandler.do_open(self, http_class, req, **http_conn_args)
     1346         h.request(req.get_method(), req.selector, req.data, headers,
     1347                   encode_chunked=req.has_header('Transfer-encoding'))
     1348     except OSError as err: # timeout error
  -> 1349         raise URLError(err)
     1350     r = h.getresponse()
     1351 except:
  
  URLError: <urlopen error _ssl.c:1112: The handshake operation timed out>
  
```
</details>

### Versions

```shell
System:
    python: 3.9.7 (default, Sep 16 2021, 13:09:58)  [GCC 7.5.0]
executable: /home/mathurin/anaconda3/bin/python
   machine: Linux-5.13.0-40-generic-x86_64-with-glibc2.31

Python dependencies:
      sklearn: 1.2.dev0
          pip: 21.2.4
   setuptools: 58.0.4
        numpy: 1.20.3
        scipy: 1.7.3
       Cython: 0.29.28
       pandas: 1.4.1
   matplotlib: 3.5.1
       joblib: 1.1.0
threadpoolctl: 2.2.0

Built with OpenMP: False

threadpoolctl info:
       filepath: /home/mathurin/anaconda3/lib/python3.9/site-packages/numpy.libs/libopenblasp-r0-5bebc122.3.13.dev.so
         prefix: libopenblas
       user_api: blas
   internal_api: openblas
        version: 0.3.13.dev
    num_threads: 8
threading_layer: pthreads
   architecture: Prescott

       filepath: /home/mathurin/anaconda3/lib/libmkl_rt.so.1
         prefix: libmkl_rt
       user_api: blas
   internal_api: mkl
        version: 2021.4-Product
    num_threads: 4
threading_layer: intel

       filepath: /home/mathurin/anaconda3/lib/libiomp5.so
         prefix: libiomp
       user_api: openmp
   internal_api: openmp
        version: None
    num_threads: 8
```

COMMENT:
I cannot reproduce this problem with `"titanic"` or `"iris"`. There must be something specific to `"leukemia"`.

Labels: Bug