REPLACE INTO st_cat.content (md5_url, url, last_updated, article_date, article_id, game_id, state, status, last_requested_www, last_requested_amp, last_processed_www, last_processed_amp, request_no_www, request_no_amp, www, amp) VALUES ('b67f460c533e2c00ab1167ee1a373c76', '/football/man-utd/news/', '2019-10-17 18:57:16', '0000-00-00 00:00:00', '0', '0', '1', '9', '2019-10-17 18:57:16', '2019-10-17 18:57:20', '2019-10-18 10:54:24', '2019-10-18 10:54:57', '1', '1', '<!doctype html><html
xmlns="https://www.w3.org/1999/xhtml" xmlns:og="http://opengraphprotocol.org/schema/" xmlns:fb="https://www.facebook.com/2008/fbml" xml:lang="en-GB" lang="en-GB"><head><meta
http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Manchester United  News - Sports Mole</title><meta
name="keywords" content="Manchester United, Football, news, sports mole, Football" /><meta
name="description" content="Latest Manchester United Football news from Sports Mole" /><link
rel="canonical" href="https://www.sportsmole.co.uk/football/man-utd/news/" /><meta
property="fb:pages" content="205985596102324" /><meta
property="fb:pages" content="723025957708065" /><meta
property="fb:pages" content="616634985038528" /><meta
property="og:title" content="Manchester United  News"><meta
property="og:description" content="Latest Manchester United Football news from Sports Mole"><meta
property="og:image" content="https://sm.imgix.net/16/48/sports-mole.jpg?w=300&h=225"><link
rel="next" href="https://www.sportsmole.co.uk/football/man-utd/news/page-2/" /><link
id="amphtml" rel="amphtml" href="https://amp.sportsmole.co.uk/football/man-utd/news/" /><meta
name="msvalidate.01" content="FBCBA0B507C67AD697683114E5CA1261" /><meta
name="inmobi-site-verification" content="5692cf06b29dc08b1f0b5bcc4fa9a236" /><meta
name="axl-verification" content="4f444850-a871-11e9-a465-d74b33f42865"><meta
property="fb:page_id" content="205985596102324" /><meta
property="fb:app_id" content="190968397630061" /><meta
property="fb:admins" content="309601628,631550153,507983199,600160699,586228445" /><meta
name="p:domain_verify" content="63654da0385ba65f69041591f1933266" /><meta
name="apple-mobile-web-app-capable" content="yes" /><meta
name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no" /><meta
name="theme-color" content="#1D411D" /><link
rel="apple-touch-icon" sizes="144x144" href="https://sm.imgix.net/13/14/apple-touch-icon-precomposed.png?w=144&h=144" /><link
rel="apple-touch-icon" sizes="114x114" href="https://sm.imgix.net/13/14/apple-touch-icon-precomposed_1.png?w=114&h=114" /><link
rel="apple-touch-icon" sizes="72x72" href="https://sm.imgix.net/13/14/apple-touch-icon-precomposed_2.png?w=72&h=72" /><link
rel="apple-touch-icon" href="https://sm.imgix.net/13/14/apple-touch-icon-precomposed_3.png?w=57&h=57" /><meta
property="twitter:card" content="summary_large_image" /><meta
property="twitter:site" content="@SportsMole" /><meta
property="twitter:site:id" content="279751136" /><meta
name="twitter:creator" content="@SportsMole" /><link
rel="alternate" type="application/rss+xml" title="Sports Mole: Global" href="https://www.sportsmole.co.uk/rss.xml" /><link
rel="alternate" type="application/rss+xml" title="Sports Mole: Football" href="https://www.sportsmole.co.uk/football/rss.xml" /><link
rel="alternate" type="application/rss+xml" title="Sports Mole: Manchester United" href="https://www.sportsmole.co.uk/football/man-utd.xml" /><link
rel="alternate" type="application/json" title="Sports Mole: Latest headlines from Sports Mole" href="https://www.sportsmole.co.uk/feed.json" /> <script async src="https://cdn.ampproject.org/v0.js"></script> <script async custom-element="amp-analytics" src="https://cdn.ampproject.org/v0/amp-analytics-0.1.js"></script> <script async custom-element="amp-list" src="https://cdn.ampproject.org/v0/amp-list-0.1.js"></script> <script async custom-element="amp-social-share" src="https://cdn.ampproject.org/v0/amp-social-share-0.1.js"></script> <script async custom-element="amp-form" src="https://cdn.ampproject.org/v0/amp-form-0.1.js"></script> <script async custom-element="amp-fit-text" src="https://cdn.ampproject.org/v0/amp-fit-text-0.1.js"></script> 
<script async custom-element="amp-access" src="https://cdn.ampproject.org/v0/amp-access-0.1.js"></script> <script async custom-template="amp-mustache" src="https://cdn.ampproject.org/v0/amp-mustache-0.2.js"></script> <script id="amp-access" type="application/json">{
		"authorization": "https://www.sportsmole.co.uk/amp_ping/READER_IDRANDOM1/?rid=READER_ID&uri=SOURCE_URL&pass=PIK&_=RANDOM&host=www.sportsmole.co.uk&ht=https:&site=www&FB=OK&ref=SOURCE_URL&dynamic", 
		"pingback": "https://www.sportsmole.co.uk/amp_ping/READER_IDRANDOM2/?rid=READER_ID&uri=SOURCE_URL&pass=PING&_=RANDOM&host=www.sportsmole.co.uk&ht=https:&sport=&art=&team=&site=www&dynamic", 
		"login": {
			"auth": "https://usepik.com/api/v1/action.html?a=login&s=d37f90dd-6ca7-460f-b35c-b84d385285ef&fb=134405363790145&t=ref:adfree&tptype=amp-reader&tpid=READER_ID&return=RETURN_URL",
			"buy": "https://usepik.com/api/v1/action.html?a=purchase&s=d37f90dd-6ca7-460f-b35c-b84d385285ef&fb=134405363790145&t=ref:adfree&tptype=amp-reader&tpid=READER_ID&return=RETURN_URL",
			"buy_annual": "https://usepik.com/api/v1/action.html?a=purchase&s=d37f90dd-6ca7-460f-b35c-b84d385285ef&fb=134405363790145&t=ref:adfree&c=c18a83c9-a492-47d1-85cc-a88050801127&tptype=amp-reader&tpid=READER_ID&return=RETURN_URL",
			"buy_monthly": "https://usepik.com/api/v1/action.html?a=purchase&s=d37f90dd-6ca7-460f-b35c-b84d385285ef&fb=134405363790145&t=ref:adfree&c=8dff334a-dd55-4fc5-9697-15f87a2c25bfd&tptype=amp-reader&tpid=READER_ID&return=RETURN_URL",
			"fblogin": "https://usepik.com/api/v1/action.html?a=facebook-login&s=d37f90dd-6ca7-460f-b35c-b84d385285ef&fb=134405363790145&tptype=amp-reader&tpid=READER_ID&return=RETURN_URL",
			"logout": "https://usepik.com/api/v1/action.html?a=logout&fb=134405363790145&tptype=amp-reader&tpid=READER_ID&return=RETURN_URL"
		},
		"authorizationFallbackResponse": {
			"error": true,
			"authenticated": false,
			  "user": {
    				"id": "-",
				"displayName": "-"
  				},
			"nowViews": 0,
			"maxViews": 10,
			"access": {
				"adfree": false,
				"facebook": false
			},
			"facebookID": 0,
			"ReaderID": 0,
			"FBName": "Friend",
			"FBNameF": "Friend",
			"PIKname": "Friend"
			
		}
	}</script> <script type="text/javascript">var d='2019-10-18 10:54:25';var notLive='1';var articleID='-';var startLC='8';var sport=["football"];var format='news';var teams=["man-utd"];var news='-';var ArticleID='-';var mod='-';var edit="-";var amp='www';var pwa='pwa';var offline='-';var site='www';var a='-';(function(){var j=document.createElement('script');j.type='text/javascript';j.async=true;j.src='https://d1naemzkka1n8z.cloudfront.net/j/20190510101157.js';var t = document.getElementsByTagName('script')[0];t.parentNode.insertBefore(j, t);})();</script> <script src="https://s.grvmedia.com/js/sportsmole-loader-min.js?v=2"></script> <link
rel="stylesheet" type="text/css" href="https://d1naemzkka1n8z.cloudfront.net/c/20191009135846.css" /><base
target="_parent" /></head><body><noscript><iframe
src="//www.googletagmanager.com/ns.html?id=GTM-PFW3H6" height="0" width="0" style="display:none;visibility:hidden" title="tagmanager"></iframe></noscript><script>var dataLayer = [];if (typeof(site)!=="undefined"){dataLayer.push({'Site': site});}if (typeof(sport)!=="undefined"){dataLayer.push({'sport': sport});}if (typeof(format)!=="undefined"){dataLayer.push({'format': format});}if (typeof(teams)!=="undefined"){dataLayer.push({'teams': teams});}if (typeof(indepths)!=="undefined"){dataLayer.push({'indepths': indepths});}if (typeof(division)!=="undefined"){dataLayer.push({'division': division});}if (typeof(page)!=="undefined"){dataLayer.push({'page': page});}if (typeof(device)!=="undefined"){dataLayer.push({'device': device});}dataLayer.push({'width': '' + screen.width});dataLayer.push({'height': '' + screen.height});(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src='//www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);})(window,document,'script','dataLayer','GTM-PFW3H6');</script><span
class="hide"> MX23RW : Friday, October 18 10:54:25| >> :60:70:70: </span><div
id="fb-root"></div><div
id="twitter_div"></div><esi:include src="/esi/917/0/index.html" /><esi:remove><div
id="wrapper"><div
id="header"> <span
class="smExAqH" amp-access="NOT access.adfree"></span><div
id="toolbar"><div
id="auto_refresh"><a
href="#" id="aa_switch_on" onclick="return toggleAA()" class="aa_switch on selected"></a><a
href="#" id="aa_switch_off" onclick="return toggleAA()" class="aa_switch off"></a></div><div
id="social"> <a
target="_blank" title="Facebook" href="https://www.facebook.com/sportsmole" id="social_fb"></a> <a
target="_blank" title="Twitter" href="https://twitter.com/SportsMole" id="social_twitter"></a> <a
target="_blank" title="Instagram" href="https://instagram.com/sportsmole" id="social_instagram"></a></div></div><a
name="top"></a><div
id="todaybar"> <a
onclick="return false" href="/sitemap.html" id="sections_button"></a><div
id="logo"> <a
id="logoimage" href="/"><img
class="l" src="https://d1sew2ts8kb61y.cloudfront.net/15/38/sports-mole.png?w=347&h=66" alt="The Sports Mole mole clutching a rugby ball" width="347" height="66" /></a><div
id="logodate"><div
id="center" class="center FFF tAmp" title="Cardiff vs. Sheff Weds:"><a
id="transferlink" href="/football/cardiff-city/preview/preview-cardiff-vs-sheffield-wednesday-prediction-team-news-lineups_375166.html" title="Cardiff vs. Sheff Weds:" class="FFF"><span
class="FFF">Cardiff vs. Sheff Weds: <span
id="deadline" class="time FFF">7 hrs<span
class="minutes FFF"> 50 mins</span></span></span></a></div></div></div></div><form
id="searchform" name="searchform" method="get" action="/search/"><div
id="search_box"><input
id="search_for" name="s" type="text" value="" /></div> <input
title="Search" id="search_button" onclick="return clickSearch();" type="submit" name="Search" value="" /></form><div
id="topnav_wrapper" class="scroll_wrapper"><div
id="topnav" class="topnav scroll"><div
class="topnavlogoimage"><a
href="/" title="Sports Mole Home"><img
src="https://sm.imgix.net/18/47/30x30-sm-loge.png?w=30&h=30" alt="Sports Mole" width="30" height="30" /></a></div><ul
class="top_links"><li
class="pinned mobile_only"><a
id="nav_home" href="/">Home</a></li><li
class="pinned"><a
id="nav_headlines" href="/headlines/">Headlines</a></li><li
class="pinned mobile_only"><a
id="nav_live-scores" href="/live-scores/">Live Scores</a></li><li
class="pinned mobile_only"><a
id="nav_tables" href="/football/premier-league/2019-20/">Tables</a></li><li
class="pinned mobile_only"><a
id="nav_teams" href="#">Teams and Leagues<span
class="mob_down_arrow"></span></a></li><li
class="currentlink"><a
id="nav_football" href="/football/">Football</a></li><li><a
id="nav_football-transfer-talk" href="/football/transfer-talk/">Transfers</a></li><li><a
id="nav_live-scores" href="/live-scores/">Live Scores</a></li><li><a
id="nav_formula-1" href="/formula-1/">F1</a></li><li><a
id="nav_tennis" href="/tennis/">Tennis</a></li><li><a
id="nav_rugby-union" href="/rugby-union/">Rugby U</a></li><li><a
id="nav_cricket" href="/cricket/">Cricket</a></li><li><a
id="nav_golf" href="/golf/">Golf</a></li><li><a
id="nav_boxing" href="/boxing/">Boxing</a></li><li><a
id="nav_american-football" href="/american-football/">NFL</a></li><li><a
id="nav_basketball" href="/basketball/">NBA</a></li><li><a
id="nav_off-the-pitch" href="/off-the-pitch/">Off The Pitch</a></li><li><a
id="nav_more-sports" href="/more-sports/">More</a></li></ul><div
id="search_wrapper"></div></div></div><div
id="ht_wrapper"><div
id="hot_topics1" class="hot_topics"><ul
class="ht"><li><a
href="/football/cardiff-city/preview/preview-cardiff-vs-sheffield-wednesday-prediction-team-news-lineups_375166.html">Preview: Cardiff vs. Sheff Weds</a></li><li><a
href="/football/psg/preview/preview-nice-vs-psg-prediction-team-news-lineups_375181.html">Preview: Nice vs. PSG</a></li><li><a
href="/rugby-union/england/rugby-world-cup/feature/rugby-world-cup-an-in-depth-guide-to-the-eight-quarter-finalists_374988.html">In focus: RWC quarter-finalists</a></li><li><a
href="/football/premier-league/table.html">Premier League table</a></li><li><a
href="/rugby-union/rugby-world-cup/">RWC 2019 latest</a></li></ul></div></div></div><div
id="overall_content"><span
class="hidden">NO ESI</span></esi:remove><div
id="content"><div
id="breadcrumb_wrapper"><div
id="breadcrumb"> <span
class="bc_item bc_first" itemscope itemtype="https://schema.org/breadcrumb"><a
href="/" itemprop="url"><span
itemprop="title">Home</span></a></span><span
class="bc_arrow"> > </span><span
class="bc_item bc_1" itemscope itemtype="https://schema.org/breadcrumb"><a
href="/football/" itemprop="url"><span
itemprop="title">Football</span></a></span><span
class="bc_arrow"> > </span><span
class="bc_item bc_2" itemscope itemtype="https://schema.org/breadcrumb"><a
href="/football/man-utd/" itemprop="url"><span
itemprop="title">Manchester United</span></a></span><span
class="bc_arrow"> > </span><span
class="bc_item bc_3 bc_last" itemscope itemtype="https://schema.org/breadcrumb"><a
href="/football/man-utd/news/" itemprop="url"><span
itemprop="title">News</span></a></span></div></div><div
class="team_header amp1"><div
class="team_colour"  style="background-color:#C70101" ></div><div
class="team_stadium"><a
class="FFF" href="/football/man-utd/"><div
class="team_stadium_image"><img
src="https://sm.imgix.net/12/51/old-trafford-manchester-united_3.jpg?w=676&h=60&fit=crop,top,left" alt="General view of Old Trafford" width="676" height="60" /></div><div
class="teamLogo"><a
href="/football/man-utd/" title="Manchester United"><img
class="Manchester United" src="https://sm.imgix.net/19/06/manlog.png?w=40&h=40&auto=compress,format&fit=clip" alt="Manchester United logo" width="40" height="40" /></a></div><div
class="team_name amp2"><h1><a
class="FFF" href="/football/man-utd/">Manchester United</a></h1></div> </a></div><div
class="gamesub"><ul
class="game_links"><li><a
href="/football/man-utd/news/">News</a></li><li><a
href="/football/man-utd/2019-20/fixtures-and-results.html">Fixtures &amp; Results</a></li><li><a
href="/football/man-utd/squad.html">Squad</a></li><li><a
href="/football/man-utd/2019-20/top-scorers.html">Top Scorers</a></li><li><a
href="/football/man-utd/transfer-talk/">Transfer Talk</a></li><li><a
href="/football/man-utd/injury-news/">Injury News</a></li><li><a
href="/football/man-utd/feature/latest-social-updates-manchester-united_267660.html">Social</a></li><li><a
title="Manchester United Under-21s" href="/football/man-utd-21s/">Man Utd U21s</a></li><li><a
href="/football/man-utd/information/club-information-manchester-united_343414.html">Team Info</a></li></ul></div></div><div
id="sport_name" class="fw sport_bar topnav sport_title_bar"><h1>Manchester United News</h1></div><a
href="/football/man-utd/sack-race/news/ole-gunnar-solskjaer-manchester-united-job-is-not-too-big-for-me_375374.html" title="United enter the weekend two points off the relegation zone." class="fw p1_top_story red"> <img
class="l" src="https://sm.imgix.net/19/41/ole-gunnar-solskjaer.jpg?w=640&h=480&auto=compress,format&fit=clip" alt="Ole Gunnar Solskjaer: 'Manchester United job is not too big for me'" width="640" height="480" /><div
class="p1_wrap_text"><h1 class="p1_text title p1_title_text" >Ole Gunnar Solskjaer: 'Manchester United job is not too big for me'</h1></div><div
class="p1_text description">United enter the weekend two points off the relegation zone.</div> </a><div
class="homepage_left hp"></div><div
class="homepage_right hp table"></div><div
class="homepage_panel f2c table"><div
class="std_bk1 fL hp"><div
class="std_bk1 hp" ><div
class="hw gen_block hp"><div
class="sport_top_list amp hp"><div
class="Art2 bg1"> <a
href="/football/man-utd/news/ole-gunnar-solskjaer-i-dont-expect-david-de-gea-to-face-liverpool_375361.html" title="Midfielder Paul Pogba is definitely out of the match." class="list_module_row list_module_row_first hp"><amp-img
class="sm-amp-img sm-3small-amp sm-3small-new" src="https://sm.imgix.net/19/42/david-de-gea.jpg?w=144&h=108&auto=compress,format&fit=clip" width="144" height="108" attribution="&copy; Reuters" alt="&lt;span class=&quot;p2_new s hp&quot;&gt;NEW&lt;/span&gt; Ole Gunnar Solskjaer: 'I don't expect David de Gea to face Liverpool'"><div
placeholder class="fall">&C</div><noscript><img
src="https://sm.imgix.net/19/42/david-de-gea.jpg?w=144&h=108&auto=compress,format&fit=clip" width="144" height="108" alt="&lt;span class=&quot;p2_new s hp&quot;&gt;NEW&lt;/span&gt; Ole Gunnar Solskjaer: 'I don't expect David de Gea to face Liverpool'"></noscript></amp-img><div
class="large_titleTL"><span
class="p2_new s hp">NEW</span> Ole Gunnar Solskjaer: 'I don't expect David de Gea to face Liverpool'<br
/><span
class="black tAgo hp"> 1h</span></div></a></div><div
class="Art2R bg2"> <a
href="/football/man-utd/transfer-talk/news/dembele-keen-on-england-return-amid-man-utd-talk_375356.html" title="Lyon forward Moussa Dembele, an alleged target for Manchester United, is reportedly keen to return to England at the end of the season." class="list_module_row list_module_row_first hp"><amp-img
class="sm-amp-img sm-3small-amp" src="https://sm.imgix.net/19/15/moussa-dembele.jpg?w=144&h=108&auto=compress,format&fit=clip" width="144" height="108" attribution="&copy; Reuters" alt="Lyon's Moussa Dembele keen on England return amid Manchester United talk?"><div
placeholder class="fall">LM</div><noscript><img
src="https://sm.imgix.net/19/15/moussa-dembele.jpg?w=144&h=108&auto=compress,format&fit=clip" width="144" height="108" alt="Lyon's Moussa Dembele keen on England return amid Manchester United talk?"></noscript></amp-img><div
class="large_titleTR">Lyon's Moussa Dembele keen on England return amid Manchester United talk?<br
/><span
class="black tAgo hp">Transfer Talk | 2h</span></div></a></div></div></div></div></div><div
class="std_bk1 fL hp"><div
class="std_bk1 hp" ><div
class="hw gen_block hp"><div
class="sport_top_list amp hp"><div
class="Art2 bg1"> <a
href="/football/man-utd/transfer-talk/news/zidane-meets-with-pogba-in-dubai_375354.html" title="Real Madrid manager Zinedine Zidane meets with Manchester United midfielder Paul Pogba in Dubai during their respective breaks from domestic action." class="list_module_row list_module_row_first hp"><amp-img
class="sm-amp-img sm-3small-amp" src="https://sm.imgix.net/19/28/paul-pogba.jpg?w=144&h=108&auto=compress,format&fit=clip" width="144" height="108" attribution="&copy; Reuters" alt="Real Madrid boss Zinedine Zidane meets with Man United's Paul Pogba in Dubai"><div
placeholder class="fall">RM</div><noscript><img
src="https://sm.imgix.net/19/28/paul-pogba.jpg?w=144&h=108&auto=compress,format&fit=clip" width="144" height="108" alt="Real Madrid boss Zinedine Zidane meets with Man United's Paul Pogba in Dubai"></noscript></amp-img><div
class="large_titleTL">Real Madrid boss Zinedine Zidane meets with Man United's Paul Pogba in Dubai<br
/><span
class="black tAgo hp">Transfer Talk | 2h</span></div></a></div><div
class="Art2R bg2"> <a
href="/football/man-utd/transfer-talk/news/inter-to-offer-matic-man-utd-escape-route_375351.html" title="Inter Milan are reportedly contemplating a January approach for Manchester United midfielder Nemanja Matic." class="list_module_row list_module_row_first hp"><amp-img
class="sm-amp-img sm-3small-amp" src="https://sm.imgix.net/18/41/nemanja-matic.jpg?w=144&h=108&auto=compress,format&fit=clip" width="144" height="108" attribution="&copy; Reuters" alt="Inter Milan to offer Nemanja Matic an escape route from Manchester United?"><div
placeholder class="fall">IM</div><noscript><img
src="https://sm.imgix.net/18/41/nemanja-matic.jpg?w=144&h=108&auto=compress,format&fit=clip" width="144" height="108" alt="Inter Milan to offer Nemanja Matic an escape route from Manchester United?"></noscript></amp-img><div
class="large_titleTR">Inter Milan to offer Nemanja Matic an escape route from Manchester United?<br
/><span
class="black tAgo hp">Transfer Talk | 2h</span></div></a></div></div></div></div></div></div><div
class="sport_top_list" style="margin-bottom: 10px;display: table;"><div
class="std_bk1 fL hp" ><div
class="hw gen_block hp"><div
class="sport_top_list amp hp"><div
class="Art3 bg2 h80"> <a
href="/football/man-utd/manchester-united-transfer-daily-roundups/news/fridays-man-utd-transfer-talk-niguez-can-cavani_375342.html" title="Sports Mole rounds up the latest transfer talk for Manchester United on Friday, October 18 ahead of the January window." class="list_module_row list_module_row_first hp"><amp-img
class="sm-amp-img sm-3small-amp m3" src="https://sm.imgix.net/19/11/saul-niguez.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" attribution="&copy; Reuters" alt="Friday's Manchester United transfer talk news roundup: Saul Niguez, Emre Can, Edinson Cavani"><div
placeholder class="fall">FM</div><noscript><img
src="https://sm.imgix.net/19/11/saul-niguez.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" alt="Friday's Manchester United transfer talk news roundup: Saul Niguez, Emre Can, Edinson Cavani"></noscript></amp-img><div
class=" large_titleL hp0">Friday's Manchester United transfer talk news roundup: Saul Niguez, Emre Can, Edinson Cavani<br
/><span
class="black tAgo hp">Transfer Daily Roundups | 4h</span></div></a></div><div
class="Art3 bg1 h80"> <a
href="/football/man-utd/transfer-talk/news/man-utd-considering-january-bid-for-cavani_375331.html" title="Manchester United are reportedly weighing up the prospect of a January bid for Edinson Cavani." class="list_module_row list_module_row_first hp"><amp-img
class="sm-amp-img sm-3small-amp m3" src="https://sm.imgix.net/19/05/edinson-cavani.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" attribution="&copy; Reuters" alt="Manchester United considering January bid for Edinson Cavani?"><div
placeholder class="fall">MU</div><noscript><img
src="https://sm.imgix.net/19/05/edinson-cavani.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" alt="Manchester United considering January bid for Edinson Cavani?"></noscript></amp-img><div
class=" large_titleL hp1">Manchester United considering January bid for Edinson Cavani?<br
/><span
class="black tAgo hp">Transfer Talk | 12h</span></div></a></div><div
class="Art3 bg2 h80"> <a
href="/football/man-utd/sack-race/news/ed-woodward-reiterates-ole-gunnar-solskjaer-support_375325.html" title="Manchester United are in the midst of their worst start to a season in 30 years." class="list_module_row list_module_row_first hp"><amp-img
class="sm-amp-img sm-3small-amp m3" src="https://sm.imgix.net/19/41/ole-gunnar-solskjaer.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" attribution="&copy; Reuters" alt="Ed Woodward reiterates Ole Gunnar Solskjaer support"><div
placeholder class="fall">EW</div><noscript><img
src="https://sm.imgix.net/19/41/ole-gunnar-solskjaer.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" alt="Ed Woodward reiterates Ole Gunnar Solskjaer support"></noscript></amp-img><div
class=" large_titleL hp2">Ed Woodward reiterates Ole Gunnar Solskjaer support<br
/><span
class="black tAgo hp">The Sack Race | 12h</span></div></a></div></div></div></div><div
class="std_bk1 fL hp" ><div
class="hw gen_block hp"><div
class="sport_top_list amp hp"><div
class="Art3 bg2 h80"> <a
href="/football/man-utd/transfer-talk/news/man-city-join-erling-braut-haaland-race_375301.html" title="Manchester City are reportedly ready to join the race to sign Red Bull Salzburg forward Erling Braut Haaland." class="list_module_row list_module_row_first hp"><amp-img
class="sm-amp-img sm-3small-amp m3" src="https://sm.imgix.net/19/40/erling-braut-haaland.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" attribution="&copy; Reuters" alt="Manchester City join race to sign Red Bull Salzburg forward Erling Braut Haaland?"><div
placeholder class="fall">MC</div><noscript><img
src="https://sm.imgix.net/19/40/erling-braut-haaland.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" alt="Manchester City join race to sign Red Bull Salzburg forward Erling Braut Haaland?"></noscript></amp-img><div
class=" large_titleL hp0">Manchester City join race to sign Red Bull Salzburg forward Erling Braut Haaland?<br
/><span
class="black tAgo hp">Transfer Talk | 17h</span></div></a></div><div
class="Art3 bg1 h80"> <a
href="/football/man-utd/transfer-talk/news/united-spurs-battling-for-swiss-midfielder_375298.html" title="Manchester United and Tottenham Hotspur are reportedly interested in signing Borussia Monchengladbach midfielder Denis Zakaria." class="list_module_row list_module_row_first hp"><amp-img
class="sm-amp-img sm-3small-amp m3" src="https://sm.imgix.net/19/23/porswi.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" attribution="&copy; Reuters" alt="Manchester United, Tottenham Hotspur battling for Denis Zakaria?"><div
placeholder class="fall">MU</div><noscript><img
src="https://sm.imgix.net/19/23/porswi.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" alt="Manchester United, Tottenham Hotspur battling for Denis Zakaria?"></noscript></amp-img><div
class=" large_titleL hp1">Manchester United, Tottenham Hotspur battling for Denis Zakaria?<br
/><span
class="black tAgo hp">Transfer Talk | 18h</span></div></a></div><div
class="Art3 bg2 h80"> <a
href="/football/man-utd/transfer-talk/news/manchester-united-tie-youngster-brandon-williams-down-to-new-long-term-contract_375287.html" title="The 19-year-old has been with the club since the age of seven." class="list_module_row list_module_row_first hp"><amp-img
class="sm-amp-img sm-3small-amp m3" src="https://sm.imgix.net/19/42/brandon-williams.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" attribution="&copy; Reuters" alt="Manchester United tie youngster Brandon Williams down to new long-term contract"><div
placeholder class="fall">MU</div><noscript><img
src="https://sm.imgix.net/19/42/brandon-williams.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" alt="Manchester United tie youngster Brandon Williams down to new long-term contract"></noscript></amp-img><div
class=" large_titleL hp2">Manchester United tie youngster Brandon Williams down to new long-term contract<br
/><span
class="black tAgo hp">Transfer Talk | 18h</span></div></a></div></div></div></div><div
class="std_bk1 fL hp" ><div
class="hw gen_block hp"><div
class="sport_top_list amp hp"><div
class="Art3 bg1 h80"> <a
href="/football/man-utd/news/andrew-robertson-expects-manchester-united-to-produce-a-reaction_375274.html" title="Liverpool are on a 17-match winning run." class="list_module_row list_module_row_first hp"><amp-img
class="sm-amp-img sm-3small-amp m3" src="https://sm.imgix.net/19/40/andrew-robertson.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" attribution="&copy; Reuters" alt="Andrew Robertson expects Manchester United to &quot;produce a reaction&quot;"><div
placeholder class="fall">AR</div><noscript><img
src="https://sm.imgix.net/19/40/andrew-robertson.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" alt="Andrew Robertson expects Manchester United to &quot;produce a reaction&quot;"></noscript></amp-img><div
class=" large_titleL hp0">Andrew Robertson expects Manchester United to "produce a reaction"<br
/><span
class="black tAgo hp"> 20h</span></div></a></div><div
class="Art3 bg2 h80"> <a
href="/football/man-utd/transfer-talk/news/emre-can-keen-on-man-united-move_375256.html" title="Juventus midfielder Emre Can is reportedly keen on securing a move to Manchester United during the January transfer window." class="list_module_row list_module_row_first hp"><amp-img
class="sm-amp-img sm-3small-amp m3" src="https://sm.imgix.net/19/42/emre-can.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" attribution="&copy; Reuters" alt="Juventus midfielder Emre Can keen on Manchester United move?"><div
placeholder class="fall">JM</div><noscript><img
src="https://sm.imgix.net/19/42/emre-can.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" alt="Juventus midfielder Emre Can keen on Manchester United move?"></noscript></amp-img><div
class=" large_titleL hp1">Juventus midfielder Emre Can keen on Manchester United move?<br
/><span
class="black tAgo hp">Transfer Talk | 23h</span></div></a></div><div
class="Art3 bg1 h80"> <a
href="/football/man-utd/transfer-talk/news/rakitics-family-block-man-utd-move_375241.html" title="Barcelona midfielder Ivan Rakitic will not be moving to Manchester United as his family have reportedly ruled out a move to England." class="list_module_row list_module_row_first hp"><amp-img
class="sm-amp-img sm-3small-amp m3" src="https://sm.imgix.net/19/05/ivan-rakitic.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" attribution="&copy; Reuters" alt="Ivan Rakitic's family 'block Manchester United move'"><div
placeholder class="fall">IR</div><noscript><img
src="https://sm.imgix.net/19/05/ivan-rakitic.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" alt="Ivan Rakitic's family 'block Manchester United move'"></noscript></amp-img><div
class=" large_titleL hp2">Ivan Rakitic's family 'block Manchester United move'<br
/><span
class="black tAgo hp">Transfer Talk | 1d</span></div></a></div></div></div></div><div
class="std_bk1 fL hp" ><div
class="hw gen_block hp"><div
class="sport_top_list amp hp"><div
class="Art3 bg1 h80"> <a
href="/football/man-utd/transfer-talk/news/saul-among-six-manchester-united-targets_375238.html" title="Atletico Madrid midfielder Saul Niguez is reportedly one of six players being targeted by Manchester United as they look to revamp their struggling squad." class="list_module_row list_module_row_first hp"><amp-img
class="sm-amp-img sm-3small-amp m3" src="https://sm.imgix.net/19/11/saul-niguez.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" attribution="&copy; Reuters" alt="Saul Niguez among six Manchester United targets?"><div
placeholder class="fall">SN</div><noscript><img
src="https://sm.imgix.net/19/11/saul-niguez.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" alt="Saul Niguez among six Manchester United targets?"></noscript></amp-img><div
class=" large_titleL hp0">Saul Niguez among six Manchester United targets?<br
/><span
class="black tAgo hp">Transfer Talk | 1d</span></div></a></div><div
class="Art3 bg2 h80"> <a
href="/football/man-utd/news/allegri-refuses-to-deny-man-utd-speculation_375236.html" title="Former Juventus manager Massimiliano Allegri refuses to deny speculation suggesting he will replace Ole Gunnar Solskjaer as Manchester United manager." class="list_module_row list_module_row_first hp"><amp-img
class="sm-amp-img sm-3small-amp m3" src="https://sm.imgix.net/19/20/massimiliano-allegri.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" attribution="&copy; Reuters" alt="Massimiliano Allegri refuses to deny Manchester United speculation"><div
placeholder class="fall">MA</div><noscript><img
src="https://sm.imgix.net/19/20/massimiliano-allegri.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" alt="Massimiliano Allegri refuses to deny Manchester United speculation"></noscript></amp-img><div
class=" large_titleL hp1">Massimiliano Allegri refuses to deny Manchester United speculation<br
/><span
class="black tAgo hp"> 1d</span></div></a></div><div
class="Art3 bg1 h80"> <a
href="/football/man-utd/transfer-talk/news/manchester-united-boss-solskjaer-discusses-january-transfer-plans_375233.html" title="United sit 12th in the Premier League table, just two points above the relegation zone ahead of their clash with leaders Liverpool on Sunday." class="list_module_row list_module_row_first hp"><amp-img
class="sm-amp-img sm-3small-amp m3" src="https://sm.imgix.net/19/41/ole-gunnar-solskjaer.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" attribution="&copy; Reuters" alt="Manchester United boss Solskjaer discusses January transfer plans"><div
placeholder class="fall">MU</div><noscript><img
src="https://sm.imgix.net/19/41/ole-gunnar-solskjaer.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" alt="Manchester United boss Solskjaer discusses January transfer plans"></noscript></amp-img><div
class=" large_titleL hp2">Manchester United boss Solskjaer discusses January transfer plans<br
/><span
class="black tAgo hp">Transfer Talk | 1d</span></div></a></div></div></div></div><div
class="std_bk1 fL hp" ><div
class="hw gen_block hp"><div
class="sport_top_list amp hp"><div
class="Art3 bg2 h80"> <a
href="/football/man-utd/manchester-united-transfer-daily-roundups/news/thursdays-man-utd-transfer-talk-felix-solskjaer-woodward_375228.html" title="Sports Mole rounds up the latest transfer talk for Manchester United on Thursday, October 17 ahead of the January window." class="list_module_row list_module_row_first hp"><amp-img
class="sm-amp-img sm-3small-amp m3" src="https://sm.imgix.net/19/39/atmrma_1.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" attribution="&copy; Reuters" alt="Thursday's Manchester United transfer talk news roundup: Joao Felix, Ole Gunnar Solskjaer, Ed Woodward"><div
placeholder class="fall">TM</div><noscript><img
src="https://sm.imgix.net/19/39/atmrma_1.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" alt="Thursday's Manchester United transfer talk news roundup: Joao Felix, Ole Gunnar Solskjaer, Ed Woodward"></noscript></amp-img><div
class=" large_titleL hp0">Thursday's Manchester United transfer talk news roundup: Joao Felix, Ole Gunnar Solskjaer, Ed Woodward<br
/><span
class="black tAgo hp">Transfer Daily Roundups | 1d</span></div></a></div><div
class="Art3 bg1 h80"> <a
href="/football/man-utd/transfer-talk/news/zidane-ends-paul-pogba-interest_375218.html" title="Real Madrid manager Zinedine Zidane ends his interest in Manchester United midfielder Paul Pogba, according to a report." class="list_module_row list_module_row_first hp"><amp-img
class="sm-amp-img sm-3small-amp m3" src="https://sm.imgix.net/19/39/paul-pogba.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" attribution="&copy; Reuters" alt="Real Madrid boss Zinedine Zidane ends Paul Pogba interest?"><div
placeholder class="fall">RM</div><noscript><img
src="https://sm.imgix.net/19/39/paul-pogba.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" alt="Real Madrid boss Zinedine Zidane ends Paul Pogba interest?"></noscript></amp-img><div
class=" large_titleL hp1">Real Madrid boss Zinedine Zidane ends Paul Pogba interest?<br
/><span
class="black tAgo hp">Transfer Talk | 1d</span></div></a></div><div
class="Art3 bg2 h80"> <a
href="/football/man-utd/transfer-talk/news/longstaff-stalling-on-newcastle-deal-amid-man-utd-interest_375216.html" title="Newcastle United midfielder Sean Longstaff is at an impasse with the club over a new contract amid Manchester United's continued interest, according to a report." class="list_module_row list_module_row_first hp"><amp-img
class="sm-amp-img sm-3small-amp m3" src="https://sm.imgix.net/19/40/sean-longstaff.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" attribution="&copy; Reuters" alt="Sean Longstaff 'stalling on Newcastle deal amid Manchester United interest'"><div
placeholder class="fall">SL</div><noscript><img
src="https://sm.imgix.net/19/40/sean-longstaff.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" alt="Sean Longstaff 'stalling on Newcastle deal amid Manchester United interest'"></noscript></amp-img><div
class=" large_titleL hp2">Sean Longstaff 'stalling on Newcastle deal amid Manchester United interest'<br
/><span
class="black tAgo hp">Transfer Talk | 1d</span></div></a></div></div></div></div><div
class="std_bk1 fL hp" ><div
class="hw gen_block hp"><div
class="sport_top_list amp hp"><div
class="Art3 bg2 h80"> <a
href="/football/man-utd/transfer-talk/news/man-utd-using-spying-firms-to-identify-new-targets_375213.html" title="Manchester United are reportedly using a number of 'spying firms' to help them better assess potential transfers targets for the upcoming January transfer window." class="list_module_row list_module_row_first hp"><amp-img
class="sm-amp-img sm-3small-amp m3" src="https://sm.imgix.net/19/18/ed-woodward.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" attribution="&copy; Reuters" alt="Manchester United using 'spying firms' to identify new targets?"><div
placeholder class="fall">MU</div><noscript><img
src="https://sm.imgix.net/19/18/ed-woodward.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" alt="Manchester United using 'spying firms' to identify new targets?"></noscript></amp-img><div
class=" large_titleL hp0">Manchester United using 'spying firms' to identify new targets?<br
/><span
class="black tAgo hp">Transfer Talk | 1d</span></div></a></div><div
class="Art3 bg1 h80"> <a
href="/football/man-utd/injury-news/news/david-de-gea-paul-pogba-to-miss-liverpool-clash_375204.html" title="Manchester United duo are struggling with injuries ahead of the crucial Premier League match." class="list_module_row list_module_row_first hp"><amp-img
class="sm-amp-img sm-3small-amp m3" src="https://sm.imgix.net/19/42/david-de-gea.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" attribution="&copy; Reuters" alt="David de Gea, Paul Pogba to miss Liverpool clash"><div
placeholder class="fall">DD</div><noscript><img
src="https://sm.imgix.net/19/42/david-de-gea.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" alt="David de Gea, Paul Pogba to miss Liverpool clash"></noscript></amp-img><div
class=" large_titleL hp1">David de Gea, Paul Pogba to miss Liverpool clash<br
/><span
class="black tAgo hp">Injury News | 1d</span></div></a></div><div
class="Art3 bg2 h80"> <a
href="/football/man-utd/transfer-talk/news/manchester-united-fear-difficult-january-window_375202.html" title="Manchester United fear that they will be unable to improve their squad in the January transfer window, according to a report." class="list_module_row list_module_row_first hp"><amp-img
class="sm-amp-img sm-3small-amp m3" src="https://sm.imgix.net/19/15/moussa-dembele.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" attribution="&copy; Reuters" alt="Manchester United 'fear difficult January window'"><div
placeholder class="fall">MU</div><noscript><img
src="https://sm.imgix.net/19/15/moussa-dembele.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" alt="Manchester United 'fear difficult January window'"></noscript></amp-img><div
class=" large_titleL hp2">Manchester United 'fear difficult January window'<br
/><span
class="black tAgo hp">Transfer Talk | 1d</span></div></a></div></div></div></div><div
class="std_bk1 fL hp" ><div
class="hw gen_block hp"><div
class="sport_top_list amp hp"><div
class="Art3 bg1 h80"> <a
href="/football/man-utd/news/juan-mata-beating-liverpool-can-change-manchester-united-fortunes_375193.html" title="The Red Devils are 12th in the table." class="list_module_row list_module_row_first hp"><amp-img
class="sm-amp-img sm-3small-amp m3" src="https://sm.imgix.net/19/41/juan-mata.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" attribution="&copy; Reuters" alt="Juan Mata: 'Beating Liverpool can change Manchester United fortunes'"><div
placeholder class="fall">JM</div><noscript><img
src="https://sm.imgix.net/19/41/juan-mata.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" alt="Juan Mata: 'Beating Liverpool can change Manchester United fortunes'"></noscript></amp-img><div
class=" large_titleL hp0">Juan Mata: 'Beating Liverpool can change Manchester United fortunes'<br
/><span
class="black tAgo hp"> 1d</span></div></a></div><div
class="Art3 bg2 h80"> <a
href="/football/man-utd/injury-news/news/alexis-sanchez-undergoes-surgery-on-ankle-injury_375191.html" title="The forward sustained the issue playing for Chile over the weekend." class="list_module_row list_module_row_first hp"><amp-img
class="sm-amp-img sm-3small-amp m3" src="https://sm.imgix.net/19/42/alexis-sanchez.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" attribution="&copy; Reuters" alt="Alexis Sanchez undergoes surgery on ankle injury"><div
placeholder class="fall">AS</div><noscript><img
src="https://sm.imgix.net/19/42/alexis-sanchez.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" alt="Alexis Sanchez undergoes surgery on ankle injury"></noscript></amp-img><div
class=" large_titleL hp1">Alexis Sanchez undergoes surgery on ankle injury<br
/><span
class="black tAgo hp">Injury News | 1d</span></div></a></div><div
class="Art3 bg1 h80"> <a
href="/football/man-utd/news/allegri-very-close-to-agreeing-man-united-deal_375183.html" title="Former Juventus manager Massimiliano Allegri is very close to becoming Manchester United's new head coach, according to a report." class="list_module_row list_module_row_first hp"><amp-img
class="sm-amp-img sm-3small-amp m3" src="https://sm.imgix.net/19/20/massimiliano-allegri.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" attribution="&copy; Reuters" alt="Massimiliano Allegri 'very close to agreeing Manchester United deal'"><div
placeholder class="fall">MA</div><noscript><img
src="https://sm.imgix.net/19/20/massimiliano-allegri.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" alt="Massimiliano Allegri 'very close to agreeing Manchester United deal'"></noscript></amp-img><div
class=" large_titleL hp2">Massimiliano Allegri 'very close to agreeing Manchester United deal'<br
/><span
class="black tAgo hp"> 1d</span></div></a></div></div></div></div><div
class="std_bk1 fL hp" ><div
class="hw gen_block hp"><div
class="sport_top_list amp hp"><div
class="Art3 bg1 h80"> <a
href="/football/man-utd/transfer-talk/news/manchester-united-turned-down-neymar-move_375178.html" title="Manchester United reportedly decided against a summer move for Paris Saint-Germain attacker Neymar due to character concerns." class="list_module_row list_module_row_first hp"><amp-img
class="sm-amp-img sm-3small-amp m3" src="https://sm.imgix.net/19/39/neymar.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" attribution="&copy; Reuters" alt="Manchester United 'turned down Neymar move'"><div
placeholder class="fall">MU</div><noscript><img
src="https://sm.imgix.net/19/39/neymar.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" alt="Manchester United 'turned down Neymar move'"></noscript></amp-img><div
class=" large_titleL hp0">Manchester United 'turned down Neymar move'<br
/><span
class="black tAgo hp">Transfer Talk | 1d</span></div></a></div><div
class="Art3 bg2 h80"> <a
href="/football/man-utd/transfer-talk/news/man-united-decided-against-joao-felix-move_375177.html" title="Manchester United held discussions with Benfica over a summer move for Joao Felix before deciding to drop their interest, according to a report." class="list_module_row list_module_row_first hp"><amp-img
class="sm-amp-img sm-3small-amp m3" src="https://sm.imgix.net/19/39/atmrma_1.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" attribution="&copy; Reuters" alt="Manchester United 'decided against Joao Felix move'"><div
placeholder class="fall">MU</div><noscript><img
src="https://sm.imgix.net/19/39/atmrma_1.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" alt="Manchester United 'decided against Joao Felix move'"></noscript></amp-img><div
class=" large_titleL hp1">Manchester United 'decided against Joao Felix move'<br
/><span
class="black tAgo hp">Transfer Talk | 1d</span></div></a></div><div
class="Art3 bg1 h80"> <a
href="/football/man-utd/transfer-talk/news/man-utd-fear-difficulties-with-january-signings_375156.html" title="Manchester United reportedly fear that they may struggle to complete deals over the January transfer window." class="list_module_row list_module_row_first hp"><amp-img
class="sm-amp-img sm-3small-amp m3" src="https://sm.imgix.net/19/40/ole-gunnar-solskjaer.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" attribution="&copy; Reuters" alt="Manchester United fear difficulties with January signings?"><div
placeholder class="fall">MU</div><noscript><img
src="https://sm.imgix.net/19/40/ole-gunnar-solskjaer.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" alt="Manchester United fear difficulties with January signings?"></noscript></amp-img><div
class=" large_titleL hp2">Manchester United fear difficulties with January signings?<br
/><span
class="black tAgo hp">Transfer Talk | 2d</span></div></a></div></div></div></div><div
class="std_bk1 fL hp" ><div
class="hw gen_block hp"><div
class="sport_top_list amp hp"><div
class="Art3 bg2 h80"> <a
href="/football/man-utd/transfer-talk/news/rakitic-considering-man-utd-juventus-moves_375153.html" title="Ivan Rakitic is reportedly weighing up the possibility of completing moves to either Juventus or Manchester United in the January transfer window." class="list_module_row list_module_row_first hp"><amp-img
class="sm-amp-img sm-3small-amp m3" src="https://sm.imgix.net/18/34/ivan-rakitic.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" attribution="&copy; Reuters" alt="Ivan Rakitic considering Manchester United, Juventus moves?"><div
placeholder class="fall">IR</div><noscript><img
src="https://sm.imgix.net/18/34/ivan-rakitic.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" alt="Ivan Rakitic considering Manchester United, Juventus moves?"></noscript></amp-img><div
class=" large_titleL hp0">Ivan Rakitic considering Manchester United, Juventus moves?<br
/><span
class="black tAgo hp">Transfer Talk | 2d</span></div></a></div><div
class="Art3 bg1 h80"> <a
href="/football/man-utd/injury-news/news/inter-milan-confirm-alexis-sanchez-ankle-ligament-damage_375100.html" title="The forward is on loan at Inter Milan from Manchester United." class="list_module_row list_module_row_first hp"><amp-img
class="sm-amp-img sm-3small-amp m3" src="https://sm.imgix.net/19/42/alexis-sanchez.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" attribution="&copy; Reuters" alt="Inter Milan confirm Alexis Sanchez ankle ligament damage"><div
placeholder class="fall">IM</div><noscript><img
src="https://sm.imgix.net/19/42/alexis-sanchez.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" alt="Inter Milan confirm Alexis Sanchez ankle ligament damage"></noscript></amp-img><div
class=" large_titleL hp1">Inter Milan confirm Alexis Sanchez ankle ligament damage<br
/><span
class="black tAgo hp">Injury News | 2d</span></div></a></div><div
class="Art3 bg2 h80"> <a
href="/football/man-utd/manchester-united-transfer-daily-roundups/news/wednesdays-man-utd-transfer-talk-solskjaer-pogba-can_375145.html" title="Sports Mole rounds up the latest transfer talk for Manchester United on Wednesday, October 16 ahead of the January window." class="list_module_row list_module_row_first hp"><amp-img
class="sm-amp-img sm-3small-amp m3" src="https://sm.imgix.net/19/34/ole-gunnar-solskjaer_1.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" attribution="&copy; Reuters" alt="Wednesday's Manchester United transfer talk news roundup: Ole Gunnar Solskjaer, Paul Pogba, Emre Can"><div
placeholder class="fall">WM</div><noscript><img
src="https://sm.imgix.net/19/34/ole-gunnar-solskjaer_1.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" alt="Wednesday's Manchester United transfer talk news roundup: Ole Gunnar Solskjaer, Paul Pogba, Emre Can"></noscript></amp-img><div
class=" large_titleL hp2">Wednesday's Manchester United transfer talk news roundup: Ole Gunnar Solskjaer, Paul Pogba, Emre Can<br
/><span
class="black tAgo hp">Transfer Daily Roundups | 2d</span></div></a></div></div></div></div><div
class="std_bk1 fL hp" ><div
class="hw gen_block hp"><div
class="sport_top_list amp hp"><div
class="Art3 bg2 h80"> <a
href="/football/man-utd/transfer-talk/news/paul-pogba-toni-kroos-to-swap-clubs-in-january_375128.html" title="Real Madrid will offer Toni Kroos to Manchester United as part of a bid for Paul Pogba, according to a report." class="list_module_row list_module_row_first hp"><amp-img
class="sm-amp-img sm-3small-amp m3" src="https://sm.imgix.net/19/33/paul-pogba.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" attribution="&copy; Reuters" alt="Paul Pogba, Toni Kroos to swap clubs in January?"><div
placeholder class="fall">PP</div><noscript><img
src="https://sm.imgix.net/19/33/paul-pogba.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" alt="Paul Pogba, Toni Kroos to swap clubs in January?"></noscript></amp-img><div
class=" large_titleL hp0">Paul Pogba, Toni Kroos to swap clubs in January?<br
/><span
class="black tAgo hp">Transfer Talk | 2d</span></div></a></div><div
class="Art3 bg1 h80"> <a
href="/football/man-utd/injury-news/news/de-gea-to-miss-uniteds-clash-with-liverpool_375127.html" title="David de Gea could miss Manchester United's Premier League clash with Liverpool on Sunday afternoon." class="list_module_row list_module_row_first hp"><amp-img
class="sm-amp-img sm-3small-amp m3" src="https://sm.imgix.net/19/41/david-de-gea.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" attribution="&copy; Reuters" alt="David de Gea to miss Manchester United's clash with Liverpool?"><div
placeholder class="fall">DD</div><noscript><img
src="https://sm.imgix.net/19/41/david-de-gea.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" alt="David de Gea to miss Manchester United's clash with Liverpool?"></noscript></amp-img><div
class=" large_titleL hp1">David de Gea to miss Manchester United's clash with Liverpool?<br
/><span
class="black tAgo hp">Injury News | 2d</span></div></a></div><div
class="Art3 bg2 h80"> <a
href="/football/man-utd/news/laurent-blanc-wants-manchester-united-job_375113.html" title="Former France boss Laurent Blanc is reportedly keen on replacing Ole Gunnar Solskjaer as head coach of Manchester United." class="list_module_row list_module_row_first hp"><amp-img
class="sm-amp-img sm-3small-amp m3" src="https://sm.imgix.net/18/22/laurent-blanc.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" attribution="&copy; Reuters" alt="Laurent Blanc 'wants Manchester United job'"><div
placeholder class="fall">LB</div><noscript><img
src="https://sm.imgix.net/18/22/laurent-blanc.jpg?w=82&h=62&auto=compress,format&fit=clip" width="82" height="62" alt="Laurent Blanc 'wants Manchester United job'"></noscript></amp-img><div
class=" large_titleL hp2">Laurent Blanc 'wants Manchester United job'<br
/><span
class="black tAgo hp"> 2d</span></div></a></div></div></div></div></div><div
class="next_prev_black"><div
class="next_black"><a
href="/football/man-utd/news/page-2/">Next Page <span
class="next_black_arrow">&gt;</span></a></div></div> <section
amp-access="NOT noq" amp-access-hide></section> <section
amp-access="NOT noq" amp-access-hide><br
/><div
id="carambola_quiz"><img
height='0' width='0' alt='' src='https://pixel.watch/od3l' /><script data-cfasync="false" class="carambola_InContent" type="text/javascript" cbola_wid="0">(function (i,d,s,o,m,r,t,l,w,q,y,h,g) { var e=d.getElementById(r);if(e===null){ var t = d.createElement(o); t.src = g; t.id = r; t.setAttribute(m, s);t.async = 1;var n=d.getElementsByTagName(o)[0];n.parentNode.insertBefore(t, n);var dt=new Date().getTime(); try{i[l][w+y](h,i[l][q+y](h)+'&'+dt);}catch(er){i[h]=dt;} } else if(typeof i[t]!=='undefined'){i[t]++} else{i[t]=1;} })(window, document, 'InContent', 'script', 'mediaType', 'carambola_proxy','Cbola_IC','localStorage','set','get','Item','cbolaDt','https://'+'route.carambo.la/inimage/getlayer?pid=sprt22&did=110775') window.parent.postMessage({  sentinel: 'amp', type: 'embed-size', height: document.body.scrollHeight}, '*');</script></div></section>  <script type="text/javascript" language="javascript" src="https://live.sekindo.com/live/liveView.php?s=98324&cbuster=%%CACHEBUSTER%%&pubUrl=%%REFERRER_URL_ESC%%&x=%%WIDTH%%&y=%%HEIGHT%%&vp_content=plembed1195oxyqmlhv"></script>  <esi:include src="/esi/1235/0/index.html" /><esi:remove><div
class="std_bk1 www"><div
class="hw gen_block www"><div
class="list_module_header  www ga de3343"> <a
href="/trending/"><h3 class="Ide3343">TRENDING</h3></a></div><div
class="sport_top_list www"><div
class="list one www even"> <a
href="/football/arsenal/transfer-talk/news/arsenal-to-make-january-bid-for-upamecano_375349.html" title="Arsenal will allegedly reignite their interest in RB Leipzig defender Dayot Upamecano during the January transfer window." class="list_module_row list_module_row_first www"><amp-img
class="sm-amp-img  sm-vsmall-amp www " src="https://sm.imgix.net/19/06/dayot-upamecano.jpg?w=52&h=39&auto=compress,format&fit=clip" width="52" height="39" attribution="&copy; Reuters" alt="Dayot Upamecano pictured in October 2018"><div
placeholder class="fall">DU</div><noscript><img
src="https://sm.imgix.net/19/06/dayot-upamecano.jpg?w=52&h=39&auto=compress,format&fit=clip" width="52" height="39" alt="Dayot Upamecano pictured in October 2018"></noscript></amp-img><div
class="large_title www"><amp-fit-text
width="240" height="40" layout="responsive" min-font-size="12" max-font-size="13">Arsenal to make January bid for Upamecano?</amp-fit-text></div></a></div><div
class="list one www odd"> <a
href="/football/man-utd/transfer-talk/news/dembele-keen-on-england-return-amid-man-utd-talk_375356.html" title="Lyon forward Moussa Dembele, an alleged target for Manchester United, is reportedly keen to return to England at the end of the season." class="list_module_row list_module_row_first www"><amp-img
class="sm-amp-img  sm-vsmall-amp www " src="https://sm.imgix.net/19/15/moussa-dembele.jpg?w=52&h=39&auto=compress,format&fit=clip" width="52" height="39" attribution="&copy; Reuters" alt="Lyon forward Moussa Dembele in action in March, 2019"><div
placeholder class="fall">LF</div><noscript><img
src="https://sm.imgix.net/19/15/moussa-dembele.jpg?w=52&h=39&auto=compress,format&fit=clip" width="52" height="39" alt="Lyon forward Moussa Dembele in action in March, 2019"></noscript></amp-img><div
class="large_title www"><amp-fit-text
width="240" height="40" layout="responsive" min-font-size="12" max-font-size="13">Dembele keen on England return amid Man Utd talk?</amp-fit-text></div></a></div><div
class="list one www even"> <a
href="/football/man-utd/transfer-talk/news/zidane-meets-with-pogba-in-dubai_375354.html" title="Real Madrid manager Zinedine Zidane meets with Manchester United midfielder Paul Pogba in Dubai during their respective breaks from domestic action." class="list_module_row list_module_row_first www"><amp-img
class="sm-amp-img  sm-vsmall-amp www " src="https://sm.imgix.net/19/28/paul-pogba.jpg?w=52&h=39&auto=compress,format&fit=clip" width="52" height="39" attribution="&copy; Reuters" alt="Paul Pogba in Premier League action for Manchester United on May 12, 2019"><div
placeholder class="fall">PP</div><noscript><img
src="https://sm.imgix.net/19/28/paul-pogba.jpg?w=52&h=39&auto=compress,format&fit=clip" width="52" height="39" alt="Paul Pogba in Premier League action for Manchester United on May 12, 2019"></noscript></amp-img><div
class="large_title www"><amp-fit-text
width="240" height="40" layout="responsive" min-font-size="12" max-font-size="13">Zidane meets with Pogba in Dubai</amp-fit-text></div></a></div><div
class="list one www odd"> <a
href="/football/liverpool/transfer-talk/news/liverpool-willing-to-sell-adam-lallana_375350.html" title="Liverpool are reportedly open to parting ways with Adam Lallana at the end of the season, providing that he does not reclaim his spot back in the starting lineup." class="list_module_row list_module_row_first www"><amp-img
class="sm-amp-img  sm-vsmall-amp www " src="https://sm.imgix.net/19/11/adam-lallana.jpg?w=52&h=39&auto=compress,format&fit=clip" width="52" height="39" attribution="&copy; Reuters" alt="Adam Lallana in action for Liverpool on March 17, 2019"><div
placeholder class="fall">AL</div><noscript><img
src="https://sm.imgix.net/19/11/adam-lallana.jpg?w=52&h=39&auto=compress,format&fit=clip" width="52" height="39" alt="Adam Lallana in action for Liverpool on March 17, 2019"></noscript></amp-img><div
class="large_title www"><amp-fit-text
width="240" height="40" layout="responsive" min-font-size="12" max-font-size="13">Liverpool willing to sell Adam Lallana?</amp-fit-text></div></a></div></div><div
class="list_module_footer www ga e5767f"> <a
class="Ie5767f" href="/trending/">Click for more trending news</a></div></div></div><div
class="std_bk1 www"><div
class="hw gen_block www"><div
class="list_module_header  www ga css1"> <a
href="/"><h3 class="Icss1">TOP STORIES</h3></a></div><div
class="sport_top_list www"><div
class="list one www even"> <a
href="/football/man-utd/sack-race/news/ed-woodward-reiterates-ole-gunnar-solskjaer-support_375325.html" title="Manchester United are in the midst of their worst start to a season in 30 years." class="list_module_row list_module_row_first www"><amp-img
class="sm-amp-img  sm-vsmall-amp www " src="https://sm.imgix.net/19/41/ole-gunnar-solskjaer.jpg?w=52&h=39&auto=compress,format&fit=clip" width="52" height="39" attribution="&copy; Reuters" alt="Manchester United manager Ole Gunnar Solskjaer pictured on October 6, 2019"><div
placeholder class="fall">MU</div><noscript><img
src="https://sm.imgix.net/19/41/ole-gunnar-solskjaer.jpg?w=52&h=39&auto=compress,format&fit=clip" width="52" height="39" alt="Manchester United manager Ole Gunnar Solskjaer pictured on October 6, 2019"></noscript></amp-img><div
class="large_title www"><amp-fit-text
width="240" height="40" layout="responsive" min-font-size="12" max-font-size="13">Ed Woodward reiterates Ole Gunnar Solskjaer support</amp-fit-text></div></a></div><div
class="list one www odd"> <a
href="/football/man-utd/transfer-talk/news/zidane-meets-with-pogba-in-dubai_375354.html" title="Real Madrid manager Zinedine Zidane meets with Manchester United midfielder Paul Pogba in Dubai during their respective breaks from domestic action." class="list_module_row list_module_row_first www"><amp-img
class="sm-amp-img  sm-vsmall-amp www " src="https://sm.imgix.net/19/28/paul-pogba.jpg?w=52&h=39&auto=compress,format&fit=clip" width="52" height="39" attribution="&copy; Reuters" alt="Paul Pogba in Premier League action for Manchester United on May 12, 2019"><div
placeholder class="fall">PP</div><noscript><img
src="https://sm.imgix.net/19/28/paul-pogba.jpg?w=52&h=39&auto=compress,format&fit=clip" width="52" height="39" alt="Paul Pogba in Premier League action for Manchester United on May 12, 2019"></noscript></amp-img><div
class="large_title www"><amp-fit-text
width="240" height="40" layout="responsive" min-font-size="12" max-font-size="13">Zidane meets with Pogba in Dubai</amp-fit-text></div></a></div><div
class="list one www even"> <a
href="/football/barcelona/news/messi-does-not-want-haaland-at-barcelona_375330.html" title="Lionel Messi is reportedly against the idea of Barcelona moving to sign Red Bull Salzburg youngster Erling Braut Haaland." class="list_module_row list_module_row_first www"><amp-img
class="sm-amp-img  sm-vsmall-amp www " src="https://sm.imgix.net/19/38/erling-braut-haaland.jpg?w=52&h=39&auto=compress,format&fit=clip" width="52" height="39" attribution="&copy; Reuters" alt="Erling Braut Haaland in action for RB Salzburg on September 17, 2019"><div
placeholder class="fall">EB</div><noscript><img
src="https://sm.imgix.net/19/38/erling-braut-haaland.jpg?w=52&h=39&auto=compress,format&fit=clip" width="52" height="39" alt="Erling Braut Haaland in action for RB Salzburg on September 17, 2019"></noscript></amp-img><div
class="large_title www"><amp-fit-text
width="240" height="40" layout="responsive" min-font-size="12" max-font-size="13">Messi 'does not want Haaland at Barcelona'</amp-fit-text></div></a></div><div
class="list one www odd"> <a
href="/football/man-utd/transfer-talk/news/dembele-keen-on-england-return-amid-man-utd-talk_375356.html" title="Lyon forward Moussa Dembele, an alleged target for Manchester United, is reportedly keen to return to England at the end of the season." class="list_module_row list_module_row_first www"><amp-img
class="sm-amp-img  sm-vsmall-amp www " src="https://sm.imgix.net/19/15/moussa-dembele.jpg?w=52&h=39&auto=compress,format&fit=clip" width="52" height="39" attribution="&copy; Reuters" alt="Lyon forward Moussa Dembele in action in March, 2019"><div
placeholder class="fall">LF</div><noscript><img
src="https://sm.imgix.net/19/15/moussa-dembele.jpg?w=52&h=39&auto=compress,format&fit=clip" width="52" height="39" alt="Lyon forward Moussa Dembele in action in March, 2019"></noscript></amp-img><div
class="large_title www"><amp-fit-text
width="240" height="40" layout="responsive" min-font-size="12" max-font-size="13">Dembele keen on England return amid Man Utd talk?</amp-fit-text></div></a></div></div><div
class="list_module_footer www ga css2"> <a
class="Icss2" href="/">Click for more top stories</a></div></div></div><div
class="std_bk1 www"><div
class="hw gen_block www"><div
class="list_module_header  www ga fff407I"> <a
href="/football/transfer-talk/"><h3 class="Ifff407I">TRANSFER NEWS</h3></a></div><div
class="sport_top_list www"><div
class="list one www even"> <a
href="/football/man-utd/transfer-talk/news/dembele-keen-on-england-return-amid-man-utd-talk_375356.html" title="Lyon forward Moussa Dembele, an alleged target for Manchester United, is reportedly keen to return to England at the end of the season." class="list_module_row list_module_row_first www"><amp-img
class="sm-amp-img  sm-vsmall-amp www " src="https://sm.imgix.net/19/15/moussa-dembele.jpg?w=52&h=39&auto=compress,format&fit=clip" width="52" height="39" attribution="&copy; Reuters" alt="Lyon forward Moussa Dembele in action in March, 2019"><div
placeholder class="fall">LF</div><noscript><img
src="https://sm.imgix.net/19/15/moussa-dembele.jpg?w=52&h=39&auto=compress,format&fit=clip" width="52" height="39" alt="Lyon forward Moussa Dembele in action in March, 2019"></noscript></amp-img><div
class="large_title www"><amp-fit-text
width="240" height="40" layout="responsive" min-font-size="12" max-font-size="13">Dembele keen on England return amid Man Utd talk?</amp-fit-text></div></a></div><div
class="list one www odd"> <a
href="/football/man-utd/transfer-talk/news/zidane-meets-with-pogba-in-dubai_375354.html" title="Real Madrid manager Zinedine Zidane meets with Manchester United midfielder Paul Pogba in Dubai during their respective breaks from domestic action." class="list_module_row list_module_row_first www"><amp-img
class="sm-amp-img  sm-vsmall-amp www " src="https://sm.imgix.net/19/28/paul-pogba.jpg?w=52&h=39&auto=compress,format&fit=clip" width="52" height="39" attribution="&copy; Reuters" alt="Paul Pogba in Premier League action for Manchester United on May 12, 2019"><div
placeholder class="fall">PP</div><noscript><img
src="https://sm.imgix.net/19/28/paul-pogba.jpg?w=52&h=39&auto=compress,format&fit=clip" width="52" height="39" alt="Paul Pogba in Premier League action for Manchester United on May 12, 2019"></noscript></amp-img><div
class="large_title www"><amp-fit-text
width="240" height="40" layout="responsive" min-font-size="12" max-font-size="13">Zidane meets with Pogba in Dubai</amp-fit-text></div></a></div><div
class="list one www even"> <a
href="/football/man-utd/transfer-talk/news/inter-to-offer-matic-man-utd-escape-route_375351.html" title="Inter Milan are reportedly contemplating a January approach for Manchester United midfielder Nemanja Matic." class="list_module_row list_module_row_first www"><amp-img
class="sm-amp-img  sm-vsmall-amp www " src="https://sm.imgix.net/18/41/nemanja-matic.jpg?w=52&h=39&auto=compress,format&fit=clip" width="52" height="39" attribution="&copy; Reuters" alt="Nemanja Matic in action for Manchester United in the Champions League on September 19, 2018"><div
placeholder class="fall">NM</div><noscript><img
src="https://sm.imgix.net/18/41/nemanja-matic.jpg?w=52&h=39&auto=compress,format&fit=clip" width="52" height="39" alt="Nemanja Matic in action for Manchester United in the Champions League on September 19, 2018"></noscript></amp-img><div
class="large_title www"><amp-fit-text
width="240" height="40" layout="responsive" min-font-size="12" max-font-size="13">Inter to offer Matic Man Utd escape route?</amp-fit-text></div></a></div><div
class="list one www odd"> <a
href="/football/liverpool/transfer-talk/news/liverpool-willing-to-sell-adam-lallana_375350.html" title="Liverpool are reportedly open to parting ways with Adam Lallana at the end of the season, providing that he does not reclaim his spot back in the starting lineup." class="list_module_row list_module_row_first www"><amp-img
class="sm-amp-img  sm-vsmall-amp www " src="https://sm.imgix.net/19/11/adam-lallana.jpg?w=52&h=39&auto=compress,format&fit=clip" width="52" height="39" attribution="&copy; Reuters" alt="Adam Lallana in action for Liverpool on March 17, 2019"><div
placeholder class="fall">AL</div><noscript><img
src="https://sm.imgix.net/19/11/adam-lallana.jpg?w=52&h=39&auto=compress,format&fit=clip" width="52" height="39" alt="Adam Lallana in action for Liverpool on March 17, 2019"></noscript></amp-img><div
class="large_title www"><amp-fit-text
width="240" height="40" layout="responsive" min-font-size="12" max-font-size="13">Liverpool willing to sell Adam Lallana?</amp-fit-text></div></a></div></div><div
class="list_module_footer www ga fff407"> <a
class="Ifff407" href="/football/transfer-talk/">Click for more transfer news</a></div></div></div><div
class="std_bk1 www"><div
class="hw gen_block www"><div
class="list_module_header  www ga css1"> <a
href="/headlines/"><h3 class="Icss1">LATEST NEWS</h3></a></div><div
class="sport_top_list www"><div
class="list one www even"> <a
href="/football/man-utd/sack-race/news/ole-gunnar-solskjaer-manchester-united-job-is-not-too-big-for-me_375374.html" title="United enter the weekend two points off the relegation zone." class="list_module_row list_module_row_first www"><amp-img
class="sm-amp-img  sm-vsmall-amp www " src="https://sm.imgix.net/19/41/ole-gunnar-solskjaer.jpg?w=52&h=39&auto=compress,format&fit=clip" width="52" height="39" attribution="&copy; Reuters" alt="Manchester United manager Ole Gunnar Solskjaer pictured on October 6, 2019"><div
placeholder class="fall">MU</div><noscript><img
src="https://sm.imgix.net/19/41/ole-gunnar-solskjaer.jpg?w=52&h=39&auto=compress,format&fit=clip" width="52" height="39" alt="Manchester United manager Ole Gunnar Solskjaer pictured on October 6, 2019"></noscript></amp-img><div
class="large_title www"><amp-fit-text
width="240" height="40" layout="responsive" min-font-size="12" max-font-size="13">Ole Gunnar Solskjaer: 'Manchester United job is not too big for me'</amp-fit-text></div></a></div><div
class="list one www odd"> <a
href="/football/kilmarnock/news/simeon-jackson-reveals-feisty-first-training-session-at-killie_375375.html" title="The forward, who has signed a short-term deal, was on the receiving end of a crunching challenge from Alan Power early in his first training session." class="list_module_row list_module_row_first www"><amp-img
class="sm-amp-img  sm-vsmall-amp www " src="https://sm.imgix.net/19/11/rugby-park-kilmarnock.jpg?w=52&h=39&auto=compress,format&fit=clip" width="52" height="39" attribution="&copy; Reuters" alt="General view of Rugby Park, home to Kilmarnock, from 2011"><div
placeholder class="fall">GV</div><noscript><img
src="https://sm.imgix.net/19/11/rugby-park-kilmarnock.jpg?w=52&h=39&auto=compress,format&fit=clip" width="52" height="39" alt="General view of Rugby Park, home to Kilmarnock, from 2011"></noscript></amp-img><div
class="large_title www"><amp-fit-text
width="240" height="40" layout="responsive" min-font-size="12" max-font-size="13">Simeon Jackson reveals feisty first training session at Killie</amp-fit-text></div></a></div><div
class="list one www even"> <a
href="/football/burnley/news/sean-dyche-looking-to-build-on-burnleys-solid-start_375372.html" title="The Clarets are currently seventh in the Premier League table." class="list_module_row list_module_row_first www"><amp-img
class="sm-amp-img  sm-vsmall-amp www " src="https://sm.imgix.net/19/39/sean-dyche.jpg?w=52&h=39&auto=compress,format&fit=clip" width="52" height="39" attribution="&copy; Reuters" alt=" Burnley boss Sean Dyche remonstrates on September 28, 2019"><div
placeholder class="fall">BB</div><noscript><img
src="https://sm.imgix.net/19/39/sean-dyche.jpg?w=52&h=39&auto=compress,format&fit=clip" width="52" height="39" alt=" Burnley boss Sean Dyche remonstrates on September 28, 2019"></noscript></amp-img><div
class="large_title www"><amp-fit-text
width="240" height="40" layout="responsive" min-font-size="12" max-font-size="13">Sean Dyche looking to build on Burnley's "solid start"</amp-fit-text></div></a></div><div
class="list one www odd"> <a
href="/football/arsenal/racism-in-football/news/unai-emery-confident-uefa-can-tackle-racist-abuse-problem_375371.html" title="The Arsenal manager said it is the responsibility of everyone in football to bring an end to racism." class="list_module_row list_module_row_first www"><amp-img
class="sm-amp-img  sm-vsmall-amp www " src="https://sm.imgix.net/19/40/unai-emery.jpg?w=52&h=39&auto=compress,format&fit=clip" width="52" height="39" attribution="&copy; Reuters" alt="Arsenal boss Unai Emery pictured on October 3, 2019"><div
placeholder class="fall">AB</div><noscript><img
src="https://sm.imgix.net/19/40/unai-emery.jpg?w=52&h=39&auto=compress,format&fit=clip" width="52" height="39" alt="Arsenal boss Unai Emery pictured on October 3, 2019"></noscript></amp-img><div
class="large_title www"><amp-fit-text
width="240" height="40" layout="responsive" min-font-size="12" max-font-size="13">Unai Emery confident UEFA can tackle racist abuse problem</amp-fit-text></div></a></div></div><div
class="list_module_footer www ga css2"> <a
class="Icss2" href="/headlines/">Click for more latest news</a></div></div></div><div
class="std_bk1 www"><div
class="hw gen_block www"><div
class="list_module_header  www ga css1"> <a
href="/most-read/"><h3 class="Icss1">MOST READ</h3></a></div><div
class="sport_top_list www"><div
class="list one www even"> <a
href="/football/chelsea/predicted-lineups/how-chelsea-could-line-up-against-newcastle_375286.html" title="Sports Mole looks at how an injury-hit Chelsea could line up for Saturday's Premier League clash with Newcastle United at Stamford Bridge." class="list_module_row list_module_row_first www"><amp-img
class="sm-amp-img  sm-vsmall-amp www " src="https://sm.imgix.net/19/41/callum-hudson-odoi.jpg?w=52&h=39&auto=compress,format&fit=clip" width="52" height="39" attribution="&copy; Reuters" alt="Chelsea's Callum Hudson-Odoi pictured in September 2019"><div
placeholder class="fall">CC</div><noscript><img
src="https://sm.imgix.net/19/41/callum-hudson-odoi.jpg?w=52&h=39&auto=compress,format&fit=clip" width="52" height="39" alt="Chelsea's Callum Hudson-Odoi pictured in September 2019"></noscript></amp-img><div
class="large_title www"><amp-fit-text
width="240" height="40" layout="responsive" min-font-size="12" max-font-size="13">How Chelsea could line up against Newcastle</amp-fit-text></div></a></div><div
class="list one www odd"> <a
href="/football/barcelona/predicted-lineups/how-barcelona-could-line-up-against-eibar_375265.html" title="Sports Mole looks at how Barcelona could line up for Saturday's La Liga clash with Eibar." class="list_module_row list_module_row_first www"><amp-img
class="sm-amp-img  sm-vsmall-amp www " src="https://sm.imgix.net/19/39/antoine-griezmann.jpg?w=52&h=39&auto=compress,format&fit=clip" width="52" height="39" attribution="&copy; Reuters" alt="Antoine Griezmann in action for Barcelona on September 14, 2019"><div
placeholder class="fall">AG</div><noscript><img
src="https://sm.imgix.net/19/39/antoine-griezmann.jpg?w=52&h=39&auto=compress,format&fit=clip" width="52" height="39" alt="Antoine Griezmann in action for Barcelona on September 14, 2019"></noscript></amp-img><div
class="large_title www"><amp-fit-text
width="240" height="40" layout="responsive" min-font-size="12" max-font-size="13">How Barcelona could line up against Eibar</amp-fit-text></div></a></div><div
class="list one www even"> <a
href="/football/juventus/predicted-lineups/how-juventus-could-line-up-against-bologna_375271.html" title="Sports Mole looks at how Juventus could line up for Saturday's Serie A clash with Bologna." class="list_module_row list_module_row_first www"><amp-img
class="sm-amp-img  sm-vsmall-amp www " src="https://sm.imgix.net/19/40/cristiano-ronaldo.jpg?w=52&h=39&auto=compress,format&fit=clip" width="52" height="39" attribution="&copy; Reuters" alt="Cristiano Ronaldo in action for Juventus on October 1, 2019"><div
placeholder class="fall">CR</div><noscript><img
src="https://sm.imgix.net/19/40/cristiano-ronaldo.jpg?w=52&h=39&auto=compress,format&fit=clip" width="52" height="39" alt="Cristiano Ronaldo in action for Juventus on October 1, 2019"></noscript></amp-img><div
class="large_title www"><amp-fit-text
width="240" height="40" layout="responsive" min-font-size="12" max-font-size="13">How Juventus could line up against Bologna</amp-fit-text></div></a></div><div
class="list one www odd"> <a
href="/football/barcelona/preview/preview-eibar-vs-barcelona-prediction-team-news-lineups_375281.html" title="Sports Mole previews Saturday's La Liga clash between Eibar and Barcelona, including predictions, team news and possible lineups." class="list_module_row list_module_row_first www"><amp-img
class="sm-amp-img  sm-vsmall-amp www " src="https://sm.imgix.net/19/40/luis-suarez.jpg?w=52&h=39&auto=compress,format&fit=clip" width="52" height="39" attribution="&copy; Reuters" alt="Luis Suarez celebrates scoring for Barcelona on October 2, 2019"><div
placeholder class="fall">LS</div><noscript><img
src="https://sm.imgix.net/19/40/luis-suarez.jpg?w=52&h=39&auto=compress,format&fit=clip" width="52" height="39" alt="Luis Suarez celebrates scoring for Barcelona on October 2, 2019"></noscript></amp-img><div
class="large_title www"><amp-fit-text
width="240" height="40" layout="responsive" min-font-size="12" max-font-size="13">Preview: Eibar vs. Barcelona - prediction, team news, lineups</amp-fit-text></div></a></div></div><div
class="list_module_footer www ga css2"> <a
class="Icss2" href="/most-read/">Click for more most read news</a></div></div></div><div
class="std_bk1 ml8 www" amp-access="NOT access.adfree"><amp-ad
width="300" height="250" type="connatix" data-connatix={"data-connatix-token":"96ca3cd2-f611-44ba-8659-3fb80a13667a"}></amp-ad></div><div
class="std_bk1 www"><div
class="std_bk1 www"><div
class="hot_topics floatL www"><div
class="w280 mAuto small_table www"><div
class="l_a hot art red www">TRENDING TOPICS</div><div
class="l_a hot art www"><li><a
href="/football/cardiff-city/preview/preview-cardiff-vs-sheffield-wednesday-prediction-team-news-lineups_375166.html">Preview: Cardiff vs. Sheff Weds</a></li></div><div
class="l_a hot art www"><li><a
href="/football/psg/preview/preview-nice-vs-psg-prediction-team-news-lineups_375181.html">Preview: Nice vs. PSG</a></li></div><div
class="l_a hot art www"><li><a
href="/rugby-union/england/rugby-world-cup/feature/rugby-world-cup-an-in-depth-guide-to-the-eight-quarter-finalists_374988.html">In focus: RWC quarter-finalists</a></li></div><div
class="l_a hot art www"><li><a
href="/football/premier-league/table.html">Premier League table</a></li></div><div
class="l_a hot art www"><li><a
href="/rugby-union/rugby-world-cup/">RWC 2019 latest</a></li></div></div></div></div></div> <span
class="hidden">NO ESI</span></esi:remove></div><div
id="rhs"> <section
amp-access="home AND access.adfree" amp-access-hide></section> <esi:include src="/esi/17/0/index.html" /><esi:remove><div
class="mpu smExAqH" id="top_mpu" amp-access="NOT access.adfree"><div
class="GRVAd" data-ad-type="primary-mpu"></div></div><span
class="hidden">NO ESI</span></esi:remove><div
id="newsnowtop" amp-access="NOT access.adfree"></div> <esi:include src="/esi/758/0/index.html" /><esi:remove><span
class="hidden">NO ESI</span></esi:remove> <esi:include src="/esi/578/T_0_1/index.html" /><esi:remove><div
id="livescoresbox"><span
class="hidden">LT: 2019-10-18 10:53:26</span><div
class="dbox_outline"><div
class="dbox_outline_pos"><div
class="inline-block dbox_outline_line_left"></div><a
class="inline-block dbox_outline_header" name="livescores" href="/football/live-scores/"><span
class="live sport">Live Football</span></a></div><div
class="live_scores_tab" id="live_scores_tab-1_2"><div>Championship</div><span
class="down_arrow"></span></div><div
class="live_scores_table" id="live_scores_table-1_2"><a
data-title="Preview: Cardiff vs. Sheffield Wednesday - prediction, team news, lineups" title="Sports Mole previews Cardiff City's clash with Sheffield Wednesday in the Championship on Friday, including predictions, team news and predicted lineups." href="/football/cardiff-city/preview/preview-cardiff-vs-sheffield-wednesday-prediction-team-news-lineups_375166.html" class="live_scores_row_even" id="ls_93154_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">7.45pm</span></div><div
class="live_scores_cell_two">Cardiff</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">Sheff Weds</div></a></div><div
class="live_scores_tab" id="live_scores_tab-1_6"><div>La Liga</div><span
class="down_arrow"></span></div><div
class="live_scores_table" id="live_scores_table-1_6"><a
data-title="99087" href="/football/la-liga/granada-vs-osasuna_game_99087.html" class="live_scores_row_even" id="ls_99087_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">8pm</span></div><div
class="live_scores_cell_two">Granada</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">Osasuna</div></a></div><div
class="live_scores_tab" id="live_scores_tab-1_8"><div>Bundesliga</div><span
class="down_arrow"></span></div><div
class="live_scores_table" id="live_scores_table-1_8"><a
data-title="99073" href="/football/bundesliga/eintracht-frankfurt-vs-bayer-leverkusen_game_99073.html" class="live_scores_row_even" id="ls_99073_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">7.30pm</span></div><div
class="live_scores_cell_two">Frankfurt</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">B. Leverkusen</div></a></div><div
class="live_scores_tab" id="live_scores_tab-1_12"><div>Ligue 1</div><span
class="down_arrow"></span></div><div
class="live_scores_table" id="live_scores_table-1_12"><a
data-title="Preview: Nice vs. PSG - prediction, team news, lineups" title="Sports Mole previews Nice's meeting with Paris Saint-Germain in Ligue 1 on Friday, including predictions, team news and predicted lineups." href="/football/psg/preview/preview-nice-vs-psg-prediction-team-news-lineups_375181.html" class="live_scores_row_even" id="ls_99070_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">7.45pm</span></div><div
class="live_scores_cell_two">Nice</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">PSG</div></a></div><div
class="live_scores_tab" id="live_scores_tab-1_3"><div>League One</div><span
class="right_arrow"></span></div><div
style="display:none"  class="live_scores_table" id="live_scores_table-1_3"><a
data-title="99060" href="/football/league-one/lincoln-city-vs-shrewsbury-town_game_99060.html" class="live_scores_row_even" id="ls_99060_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">7.45pm</span></div><div
class="live_scores_cell_two">Lincoln</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">Shrewsbury</div></a><a
data-title="99061" href="/football/league-one/tranmere-rovers-vs-southend-united_game_99061.html" class="live_scores_row_odd" id="ls_99061_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">7.45pm</span></div><div
class="live_scores_cell_two">Tranmere</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">Southend</div></a></div><div
class="live_scores_tab" id="live_scores_tab-1_14"><div>Turkish Super Lig</div><span
class="right_arrow"></span></div><div
style="display:none"  class="live_scores_table" id="live_scores_table-1_14"><a
data-title="99089" href="/football/super-lig/galatasaray-vs-sivasspor_game_99089.html" class="live_scores_row_even" id="ls_99089_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">6.30pm</span></div><div
class="live_scores_cell_two">Galatasaray</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">Sivasspor</div></a></div><div
class="live_scores_tab" id="live_scores_tab-1_56"><div>Belgian Pro League</div><span
class="right_arrow"></span></div><div
style="display:none"  class="live_scores_table" id="live_scores_table-1_56"><a
data-title="99055" href="/football/belgian-pro-league/royal-excel-mouscron-vs-club-brugge_game_99055.html" class="live_scores_row_even" id="ls_99055_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">7.30pm</span></div><div
class="live_scores_cell_two">Mouscron</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">Brugge</div></a></div><div
class="live_scores_tab" id="live_scores_tab-1_22"><div>Russian Premier League</div><span
class="right_arrow"></span></div><div
style="display:none"  class="live_scores_table" id="live_scores_table-1_22"><a
data-title="99093" href="/football/russian-premier-league/akhmat-grozny-vs-lokomotiv-moscow_game_99093.html" class="live_scores_row_even" id="ls_99093_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">5.30pm</span></div><div
class="live_scores_cell_two">Akhmat Grozny</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">Lokomotiv</div></a></div><div
class="live_scores_tab" id="live_scores_tab-1_21"><div>Ukrainian Premier League</div><span
class="right_arrow"></span></div><div
style="display:none"  class="live_scores_table" id="live_scores_table-1_21"><a
data-title="99090" href="/football/ukrainian-premier-league/shakhtar-donetsk-vs-kolos-kovalivka_game_99090.html" class="live_scores_row_even" id="ls_99090_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">5pm</span></div><div
class="live_scores_cell_two">Shakhtar</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">Kovalivka</div></a></div><div
class="live_scores_tab" id="live_scores_tab-1_76"><div>Danish Superliga</div><span
class="right_arrow"></span></div><div
style="display:none"  class="live_scores_table" id="live_scores_table-1_76"><a
data-title="99059" href="/football/danish-superliga/aalborg-bk-vs-odense_game_99059.html" class="live_scores_row_even" id="ls_99059_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">6pm</span></div><div
class="live_scores_cell_two">AaB</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">Odense</div></a></div><div
class="live_scores_tab" id="live_scores_tab-1_71"><div>Swedish Allsvenskan</div><span
class="right_arrow"></span></div><div
style="display:none"  class="live_scores_table" id="live_scores_table-1_71"><a
data-title="99088" href="/football/allsvenskan/afc-eskilstuna-vs-sundsvall_game_99088.html" class="live_scores_row_even" id="ls_99088_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">6pm</span></div><div
class="live_scores_cell_two">AFC</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">Sundsvall</div></a></div><div
class="live_scores_tab" id="live_scores_tab-1_44"><div>Segunda Division</div><span
class="right_arrow"></span></div><div
style="display:none"  class="live_scores_table" id="live_scores_table-1_44"><a
data-title="99086" href="/football/segunda-division/cadiz-vs-las-palmas_game_99086.html" class="live_scores_row_even" id="ls_99086_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">8pm</span></div><div
class="live_scores_cell_two">Cadiz</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">Las Palmas</div></a></div><div
class="live_scores_tab" id="live_scores_tab-1_55"><div>Serie B</div><span
class="right_arrow"></span></div><div
style="display:none"  class="live_scores_table" id="live_scores_table-1_55"><a
data-title="99074" href="/football/serie-b/cittadella-vs-cosenza-calcio_game_99074.html" class="live_scores_row_even" id="ls_99074_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">8pm</span></div><div
class="live_scores_cell_two">Cittadella</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">Cosenza</div></a></div><div
class="live_scores_tab" id="live_scores_tab-1_26"><div>2.Bundesliga</div><span
class="right_arrow"></span></div><div
style="display:none"  class="live_scores_table" id="live_scores_table-1_26"><a
data-title="99071" href="/football/2-bundesliga/greuther-furth-vs-dynamo-dresden_game_99071.html" class="live_scores_row_even" id="ls_99071_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">5.30pm</span></div><div
class="live_scores_cell_two">Greuther Furth</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">Dynamo Dresden</div></a><a
data-title="99072" href="/football/2-bundesliga/erzgebirge-aue-vs-nuremberg_game_99072.html" class="live_scores_row_odd" id="ls_99072_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">5.30pm</span></div><div
class="live_scores_cell_two">Erzgebirge Aue</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">Nuremberg</div></a></div><div
class="live_scores_tab" id="live_scores_tab-1_23"><div>Ligue 2</div><span
class="right_arrow"></span></div><div
style="display:none"  class="live_scores_table" id="live_scores_table-1_23"><a
data-title="99066" href="/football/ligue-2/ajaccio-vs-nancy_game_99066.html" class="live_scores_row_even" id="ls_99066_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">7pm</span></div><div
class="live_scores_cell_two">Ajaccio</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">Nancy</div></a><a
data-title="99062" href="/football/ligue-2/caen-vs-valenciennes_game_99062.html" class="live_scores_row_odd" id="ls_99062_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">7pm</span></div><div
class="live_scores_cell_two">Caen</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">Valenciennes</div></a><a
data-title="99064" href="/football/ligue-2/fc-chambly-vs-sochaux_game_99064.html" class="live_scores_row_even" id="ls_99064_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">7pm</span></div><div
class="live_scores_cell_two">FC Chambly</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">Sochaux</div></a><a
data-title="99067" href="/football/ligue-2/chateauroux-vs-paris-fc_game_99067.html" class="live_scores_row_odd" id="ls_99067_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">7pm</span></div><div
class="live_scores_cell_two">Chateauroux</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">Paris FC</div></a><a
data-title="99068" href="/football/ligue-2/clermont-vs-rodez-af_game_99068.html" class="live_scores_row_even" id="ls_99068_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">7pm</span></div><div
class="live_scores_cell_two">Clermont</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">Rodez AF</div></a><a
data-title="99065" href="/football/ligue-2/grenoble-foot-vs-orleans_game_99065.html" class="live_scores_row_odd" id="ls_99065_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">7pm</span></div><div
class="live_scores_cell_two">Grenoble</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">Orleans</div></a><a
data-title="99069" href="/football/ligue-2/niort-vs-guingamp_game_99069.html" class="live_scores_row_even" id="ls_99069_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">7pm</span></div><div
class="live_scores_cell_two">Niort</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">Guingamp</div></a><a
data-title="99063" href="/football/ligue-2/troyes-vs-le-mans_game_99063.html" class="live_scores_row_odd" id="ls_99063_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">7pm</span></div><div
class="live_scores_cell_two">Troyes</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">Le Mans</div></a></div><div
class="live_scores_tab" id="live_scores_tab-1_36"><div>Eerste Divisie</div><span
class="right_arrow"></span></div><div
style="display:none"  class="live_scores_table" id="live_scores_table-1_36"><a
data-title="99079" href="/football/eerste-divisie/cambuur-vs-oss_game_99079.html" class="live_scores_row_even" id="ls_99079_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">7pm</span></div><div
class="live_scores_cell_two">Cambuur</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">Oss</div></a><a
data-title="99083" href="/football/eerste-divisie/den-bosch-vs-roda-jc_game_99083.html" class="live_scores_row_odd" id="ls_99083_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">7pm</span></div><div
class="live_scores_cell_two">Den Bosch</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">Roda JC</div></a><a
data-title="99080" href="/football/eerste-divisie/dordrecht-vs-helmond-sport_game_99080.html" class="live_scores_row_even" id="ls_99080_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">7pm</span></div><div
class="live_scores_cell_two">Dordrecht</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">Helmond</div></a><a
data-title="99076" href="/football/eerste-divisie/fc-eindhoven-vs-nac-breda_game_99076.html" class="live_scores_row_odd" id="ls_99076_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">7pm</span></div><div
class="live_scores_cell_two">FC Eindhoven</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">NAC Breda</div></a><a
data-title="99082" href="/football/eerste-divisie/go-ahead-eagles-vs-fc-volendam_game_99082.html" class="live_scores_row_even" id="ls_99082_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">7pm</span></div><div
class="live_scores_cell_two">Go Ahead Eagles</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">Volendam</div></a><a
data-title="99078" href="/football/eerste-divisie/jong-az-vs-jong-ajax_game_99078.html" class="live_scores_row_odd" id="ls_99078_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">7pm</span></div><div
class="live_scores_cell_two">Jong AZ</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">Jong Ajax</div></a><a
data-title="99075" href="/football/eerste-divisie/jong-fc-utrecht-vs-de-graafschap_game_99075.html" class="live_scores_row_even" id="ls_99075_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">7pm</span></div><div
class="live_scores_cell_two">Jong Utrecht</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">De Graafschap</div></a><a
data-title="99081" href="/football/eerste-divisie/mvv-maastricht-vs-sbv-excelsior_game_99081.html" class="live_scores_row_odd" id="ls_99081_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">7pm</span></div><div
class="live_scores_cell_two">MVV</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">SBV Excelsior</div></a><a
data-title="99077" href="/football/eerste-divisie/nec-vs-jong-psv_game_99077.html" class="live_scores_row_even" id="ls_99077_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">7pm</span></div><div
class="live_scores_cell_two">NEC</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">Jong PSV</div></a><a
data-title="99084" href="/football/eerste-divisie/telstar-vs-almere-city_game_99084.html" class="live_scores_row_odd" id="ls_99084_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">7pm</span></div><div
class="live_scores_cell_two">Telstar</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">Almere City</div></a></div><div
class="live_scores_tab" id="live_scores_tab-1_73"><div>NIFL Premiership</div><span
class="right_arrow"></span></div><div
style="display:none"  class="live_scores_table" id="live_scores_table-1_73"><a
data-title="99085" href="/football/nifl-premiership/larne-vs-glentoran_game_99085.html" class="live_scores_row_even" id="ls_99085_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">7.45pm</span></div><div
class="live_scores_cell_two">Larne</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">Glentoran</div></a></div><div
class="live_scores_tab" id="live_scores_tab-1_72"><div>Welsh Premier League</div><span
class="right_arrow"></span></div><div
style="display:none"  class="live_scores_table" id="live_scores_table-1_72"><a
data-title="99091" href="/football/welsh-premier-league/druids-vs-caernarfon-town_game_99091.html" class="live_scores_row_even" id="ls_99091_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">7.45pm</span></div><div
class="live_scores_cell_two">Druids</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">Caernarfon</div></a><a
data-title="99092" href="/football/welsh-premier-league/carmarthen-town-vs-aberystwyth-town_game_99092.html" class="live_scores_row_odd" id="ls_99092_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">8pm</span></div><div
class="live_scores_cell_two">Carmarthen</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">Aberystwyth</div></a></div><div
class="live_scores_tab" id="live_scores_tab-1_65"><div>Premier League 2 - Div 1</div><span
class="right_arrow"></span></div><div
style="display:none"  class="live_scores_table" id="live_scores_table-1_65"><a
data-title="99094" href="/football/premier-league-2-div-1/chelsea-u23s-vs-arsenal-u23s_game_99094.html" class="live_scores_row_even" id="ls_99094_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">7pm</span></div><div
class="live_scores_cell_two">Chelsea U23s</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">Arsenal U23s</div></a><a
data-title="99095" href="/football/premier-league-2-div-1/derby-county-u23s-vs-everton-u23s_game_99095.html" class="live_scores_row_odd" id="ls_99095_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">7pm</span></div><div
class="live_scores_cell_two">Derby U23s</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">Everton U23s</div></a><a
data-title="99096" href="/football/premier-league-2-div-1/spurs-u23s-vs-leicester-city-u23s_game_99096.html" class="live_scores_row_even" id="ls_99096_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">7pm</span></div><div
class="live_scores_cell_two">Spurs U23s</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">Leicester U23s</div></a></div><div
class="live_scores_tab" id="live_scores_tab-1_66"><div>Premier League 2 - Div 2</div><span
class="right_arrow"></span></div><div
style="display:none"  class="live_scores_table" id="live_scores_table-1_66"><a
data-title="99097" href="/football/premier-league-2-div-2/middlesbrough-u23s-vs-reading-u23s_game_99097.html" class="live_scores_row_even" id="ls_99097_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">7pm</span></div><div
class="live_scores_cell_two">Boro U23s</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">Reading U23s</div></a><a
data-title="99098" href="/football/premier-league-2-div-2/norwich-city-u23s-vs-west-brom-albion-u23s_game_99098.html" class="live_scores_row_odd" id="ls_99098_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">7pm</span></div><div
class="live_scores_cell_two">Norwich U23s</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">West Brom U23s</div></a></div><div
class="live_scores_tab" id="live_scores_tab-1_60"><div>Argentine Primera Division</div><span
class="right_arrow"></span></div><div
style="display:none"  class="live_scores_table" id="live_scores_table-1_60"><a
data-title="99113" href="/football/argentina-primera-division/arsenal-sarandi-vs-river-plate_game_99113.html" class="live_scores_row_even" id="ls_99113_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">11pm</span></div><div
class="live_scores_cell_two">Arsenal</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">River Plate</div></a></div><div
class="live_scores_tab" id="live_scores_tab-1_49"><div>Australian A-League</div><span
class="right_arrow"></span></div><div
style="display:none"  class="live_scores_table" id="live_scores_table-1_49"><a
data-title="99054" href="/football/a-league/melbourne-victory-vs-western-sydney-wanderers_game_99054.html" class="live_scores_row_even" id="ls_99054_1"><div
class="live_scores_cell_one"><span
class="live_scores_ft live_scores_box">FT</span></div><div
class="live_scores_cell_two">Victory</div><div
class="live_scores_cell_three bold">1-2</div><div
class="live_scores_cell_four"><strong>Western Sydney</strong></div></a></div><div
class="live_scores_tab" id="live_scores_tab-1_61"><div>Chinese Super League</div><span
class="right_arrow"></span></div><div
style="display:none"  class="live_scores_table" id="live_scores_table-1_61"><a
data-title="99058" href="/football/chinese-super-league/shenzhen-vs-guangzhou-evergrande_game_99058.html" class="live_scores_row_even" id="ls_99058_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">12.35pm</span></div><div
class="live_scores_cell_two">Shenzhen</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">Evergrande</div></a><a
data-title="99057" href="/football/chinese-super-league/tianjin-quanjian-vs-wuhan-zall_game_99057.html" class="live_scores_row_odd" id="ls_99057_1"><div
class="live_scores_cell_one"><span
class="live_scores_pre live_scores_box">12.35pm</span></div><div
class="live_scores_cell_two">Tianjin</div><div
class="live_scores_cell_three bold">vs</div><div
class="live_scores_cell_four">Wuhan</div></a></div></div><div
class="live_scores_full_link"><span
class="Left"><a
href="/live-scores/">&gt; View full version</a></span><span
class="Right"><a
class="live_scores_full_related_right" href="/live-scores/2019-10-17.html">&gt; Yesterday's results</a></span></div></div><span
class="hidden">NO ESI</span></esi:remove><div
class="rhs_table"><div
class="dbox_outline tablerhs"><div
class="dbox_outline_pos tablerhs"><div
class="inline-block dbox_outline_line_left tablerhs"></div><div
class="inline-block dbox_outline_header tablerhs">Tables</div></div><div
class="select_tab"> <select
class="small_table_toggle"><option
selected="selected" value="1">Premier League</option><option
value="2">Championship</option><option
value="3">League One</option><option
value="4">League Two</option><option
value="52">National League</option><option
value="65">Premier League 2 - Div 1</option><option
value="66">Premier League 2 - Div 2</option><option
value="74">Women's Super League</option><option
value="45">Scottish Premiership</option><option
value="46">Scottish Championship</option><option
value="47">Scottish League One</option><option
value="48">Scottish League Two</option><option
value="72">Welsh Premier League</option><option
value="73">NIFL Premiership</option><option
value="6">La Liga</option><option
value="44">Segunda Division</option><option
value="8">Bundesliga</option><option
value="26">2.Bundesliga</option><option
value="7">Serie A</option><option
value="55">Serie B</option><option
value="12">Ligue 1</option><option
value="23">Ligue 2</option><option
value="28">Eredivisie</option><option
value="36">Eerste Divisie</option><option
value="53">Primeira Liga</option><option
value="56">Belgian Pro League</option><option
value="22">Russian Premier League</option><option
value="14">Turkish Super Lig</option><option
value="58">Greek Superleague</option><option
value="63">Norwegian Eliteserien</option><option
value="71">Swedish Allsvenskan</option><option
value="76">Danish Superliga</option><option
value="59">Swiss Super League</option><option
value="21">Ukrainian Premier League</option><option
value="13">Brasileiro</option><option
value="60">Argentine Primera Division</option><option
value="69">Liga MX</option><option
value="70">Uruguayan Primera Division</option><option
value="10">Major League Soccer</option><option
value="61">Chinese Super League</option><option
value="49">Australian A-League</option><option
value="68">Indian I-League</option></select></div><div
id="small_table"><table
class="leaguetable pX153" cellspacing="0" cellpadding="0"><tr
class="leaguetableheader pX153"><td
class="positiontd"></td><td
class="teamtd "><a
href="/football/premier-league/2019-20/table.html">Team</a></td><td
class="numbertd">P</td><td
class="numbertd mobile_only">W</td><td
class="numbertd mobile_only">D</td><td
class="numbertd mobile_only">L</td><td
class="numbertd mobile_only">F</td><td
class="numbertd mobile_only">A</td><td
class="numbertd">GD</td><td
class="numbertd">PTS</td></tr><tr ><td
class="positiontd y1">1</td><td
class="teamtd s1"><a
href="/football/liverpool/">Liverpool</a></td><td
class="numbertd">8</td><td
class="numbertd overalltd mobile_only">8</td><td
class="numbertd overalltd mobile_only">0</td><td
class="numbertd overalltd mobile_only">0</td><td
class="numbertd overalltd mobile_only">20</td><td
class="numbertd overalltd mobile_only">6</td><td
class="numbertd">14</td><td
class="positiontd"><strong>24 </strong></td></tr><tr
class="evenrow"><td
class="positiontd y2">2</td><td
class="teamtd s1"><a
class="desktop_only amp" href="/football/man-city/">Manchester City</a><a
class="mobile_only" href="/football/man-city/">Man City</a></td><td
class="numbertd">8</td><td
class="numbertd overalltd mobile_only">5</td><td
class="numbertd overalltd mobile_only">1</td><td
class="numbertd overalltd mobile_only">2</td><td
class="numbertd overalltd mobile_only">27</td><td
class="numbertd overalltd mobile_only">9</td><td
class="numbertd">18</td><td
class="positiontd"><strong>16 </strong></td></tr><tr ><td
class="positiontd y3">3</td><td
class="teamtd s1"><a
href="/football/arsenal/">Arsenal</a></td><td
class="numbertd">8</td><td
class="numbertd overalltd mobile_only">4</td><td
class="numbertd overalltd mobile_only">3</td><td
class="numbertd overalltd mobile_only">1</td><td
class="numbertd overalltd mobile_only">13</td><td
class="numbertd overalltd mobile_only">11</td><td
class="numbertd">2</td><td
class="positiontd"><strong>15 </strong></td></tr><tr
class="evenrow"><td
class="positiontd y4">4</td><td
class="teamtd s1"><a
class="desktop_only amp" href="/football/leicester-city/">Leicester City</a><a
class="mobile_only" href="/football/leicester-city/">Leicester</a></td><td
class="numbertd">8</td><td
class="numbertd overalltd mobile_only">4</td><td
class="numbertd overalltd mobile_only">2</td><td
class="numbertd overalltd mobile_only">2</td><td
class="numbertd overalltd mobile_only">14</td><td
class="numbertd overalltd mobile_only">7</td><td
class="numbertd">7</td><td
class="positiontd"><strong>14 </strong></td></tr><tr
class="dotted"><td
class="positiontd y5">5</td><td
class="teamtd s1"><a
href="/football/chelsea/">Chelsea</a></td><td
class="numbertd">8</td><td
class="numbertd overalltd mobile_only">4</td><td
class="numbertd overalltd mobile_only">2</td><td
class="numbertd overalltd mobile_only">2</td><td
class="numbertd overalltd mobile_only">18</td><td
class="numbertd overalltd mobile_only">14</td><td
class="numbertd">4</td><td
class="positiontd"><strong>14 </strong></td></tr><tr
class="evenrow dotted"><td
class="positiontd y6">6</td><td
class="teamtd s1"><a
href="/football/crystal-palace/">Crystal Palace</a></td><td
class="numbertd">8</td><td
class="numbertd overalltd mobile_only">4</td><td
class="numbertd overalltd mobile_only">2</td><td
class="numbertd overalltd mobile_only">2</td><td
class="numbertd overalltd mobile_only">8</td><td
class="numbertd overalltd mobile_only">8</td><td
class="numbertd">0</td><td
class="positiontd"><strong>14 </strong></td></tr><tr ><td
class="positiontd y7">7</td><td
class="teamtd s1"><a
href="/football/burnley/">Burnley</a></td><td
class="numbertd">8</td><td
class="numbertd overalltd mobile_only">3</td><td
class="numbertd overalltd mobile_only">3</td><td
class="numbertd overalltd mobile_only">2</td><td
class="numbertd overalltd mobile_only">11</td><td
class="numbertd overalltd mobile_only">9</td><td
class="numbertd">2</td><td
class="positiontd"><strong>12 </strong></td></tr><tr
class="evenrow"><td
class="positiontd y8">8</td><td
class="teamtd s1"><a
class="desktop_only amp" href="/football/west-ham-united/">West Ham United</a><a
class="mobile_only" href="/football/west-ham-united/">West Ham</a></td><td
class="numbertd">8</td><td
class="numbertd overalltd mobile_only">3</td><td
class="numbertd overalltd mobile_only">3</td><td
class="numbertd overalltd mobile_only">2</td><td
class="numbertd overalltd mobile_only">11</td><td
class="numbertd overalltd mobile_only">11</td><td
class="numbertd">0</td><td
class="positiontd"><strong>12 </strong></td></tr><tr ><td
class="positiontd y9">9</td><td
class="teamtd s1"><a
class="desktop_only amp" href="/football/spurs/">Tottenham Hotspur</a><a
class="mobile_only" href="/football/spurs/">Spurs</a></td><td
class="numbertd">8</td><td
class="numbertd overalltd mobile_only">3</td><td
class="numbertd overalltd mobile_only">2</td><td
class="numbertd overalltd mobile_only">3</td><td
class="numbertd overalltd mobile_only">14</td><td
class="numbertd overalltd mobile_only">12</td><td
class="numbertd">2</td><td
class="positiontd"><strong>11 </strong></td></tr><tr
class="evenrow"><td
class="positiontd y10">10</td><td
class="teamtd s1"><a
href="/football/bournemouth/">Bournemouth</a></td><td
class="numbertd">8</td><td
class="numbertd overalltd mobile_only">3</td><td
class="numbertd overalltd mobile_only">2</td><td
class="numbertd overalltd mobile_only">3</td><td
class="numbertd overalltd mobile_only">13</td><td
class="numbertd overalltd mobile_only">13</td><td
class="numbertd">0</td><td
class="positiontd"><strong>11 </strong></td></tr><tr ><td
class="positiontd y11">11</td><td
class="teamtd s1"><a
class="desktop_only amp" href="/football/wolves/">Wolverhampton Wanderers</a><a
class="mobile_only" href="/football/wolves/">Wolves</a></td><td
class="numbertd">8</td><td
class="numbertd overalltd mobile_only">2</td><td
class="numbertd overalltd mobile_only">4</td><td
class="numbertd overalltd mobile_only">2</td><td
class="numbertd overalltd mobile_only">11</td><td
class="numbertd overalltd mobile_only">11</td><td
class="numbertd">0</td><td
class="positiontd"><strong>10 </strong></td></tr><tr
class="evenrow"><td
class="positiontd y12">12</td><td
class="teamtd s1"><a
class="desktop_only amp" href="/football/man-utd/">Manchester United</a><a
class="mobile_only" href="/football/man-utd/">Man Utd</a></td><td
class="numbertd">8</td><td
class="numbertd overalltd mobile_only">2</td><td
class="numbertd overalltd mobile_only">3</td><td
class="numbertd overalltd mobile_only">3</td><td
class="numbertd overalltd mobile_only">9</td><td
class="numbertd overalltd mobile_only">8</td><td
class="numbertd">1</td><td
class="positiontd"><strong>9 </strong></td></tr><tr ><td
class="positiontd y13">13</td><td
class="teamtd s1"><a
class="desktop_only amp" href="/football/sheffield-united/">Sheffield United</a><a
class="mobile_only" href="/football/sheffield-united/">Sheff Utd</a></td><td
class="numbertd">8</td><td
class="numbertd overalltd mobile_only">2</td><td
class="numbertd overalltd mobile_only">3</td><td
class="numbertd overalltd mobile_only">3</td><td
class="numbertd overalltd mobile_only">7</td><td
class="numbertd overalltd mobile_only">7</td><td
class="numbertd">0</td><td
class="positiontd"><strong>9 </strong></td></tr><tr
class="evenrow"><td
class="positiontd y14">14</td><td
class="teamtd s1"><a
class="desktop_only amp" href="/football/brighton-and-hove-albion/">Brighton & Hove Albion</a><a
class="mobile_only" href="/football/brighton-and-hove-albion/">Brighton</a></td><td
class="numbertd">8</td><td
class="numbertd overalltd mobile_only">2</td><td
class="numbertd overalltd mobile_only">3</td><td
class="numbertd overalltd mobile_only">3</td><td
class="numbertd overalltd mobile_only">8</td><td
class="numbertd overalltd mobile_only">10</td><td
class="numbertd">-2</td><td
class="positiontd"><strong>9 </strong></td></tr><tr ><td
class="positiontd y15">15</td><td
class="teamtd s1"><a
href="/football/aston-villa/">Aston Villa</a></td><td
class="numbertd">8</td><td
class="numbertd overalltd mobile_only">2</td><td
class="numbertd overalltd mobile_only">2</td><td
class="numbertd overalltd mobile_only">4</td><td
class="numbertd overalltd mobile_only">13</td><td
class="numbertd overalltd mobile_only">12</td><td
class="numbertd">1</td><td
class="positiontd"><strong>8 </strong></td></tr><tr
class="evenrow"><td
class="positiontd y16">16</td><td
class="teamtd s1"><a
class="desktop_only amp" href="/football/newcastle-united/">Newcastle United</a><a
class="mobile_only" href="/football/newcastle-united/">Newcastle</a></td><td
class="numbertd">8</td><td
class="numbertd overalltd mobile_only">2</td><td
class="numbertd overalltd mobile_only">2</td><td
class="numbertd overalltd mobile_only">4</td><td
class="numbertd overalltd mobile_only">5</td><td
class="numbertd overalltd mobile_only">13</td><td
class="numbertd">-8</td><td
class="positiontd"><strong>8 </strong></td></tr><tr ><td
class="positiontd y17">17</td><td
class="teamtd s1"><a
href="/football/southampton/">Southampton</a></td><td
class="numbertd">8</td><td
class="numbertd overalltd mobile_only">2</td><td
class="numbertd overalltd mobile_only">1</td><td
class="numbertd overalltd mobile_only">5</td><td
class="numbertd overalltd mobile_only">8</td><td
class="numbertd overalltd mobile_only">15</td><td
class="numbertd">-7</td><td
class="positiontd"><strong>7 </strong></td></tr><tr
class="evenrow dotted"><td
class="positiontd y18">18</td><td
class="teamtd s1"><a
href="/football/everton/">Everton</a></td><td
class="numbertd">8</td><td
class="numbertd overalltd mobile_only">2</td><td
class="numbertd overalltd mobile_only">1</td><td
class="numbertd overalltd mobile_only">5</td><td
class="numbertd overalltd mobile_only">6</td><td
class="numbertd overalltd mobile_only">13</td><td
class="numbertd">-7</td><td
class="positiontd"><strong>7 </strong></td></tr><tr ><td
class="positiontd y19">19</td><td
class="teamtd s1"><a
class="desktop_only amp" href="/football/norwich-city/">Norwich City</a><a
class="mobile_only" href="/football/norwich-city/">Norwich</a></td><td
class="numbertd">8</td><td
class="numbertd overalltd mobile_only">2</td><td
class="numbertd overalltd mobile_only">0</td><td
class="numbertd overalltd mobile_only">6</td><td
class="numbertd overalltd mobile_only">10</td><td
class="numbertd overalltd mobile_only">21</td><td
class="numbertd">-11</td><td
class="positiontd"><strong>6 </strong></td></tr><tr
class="evenrow"><td
class="positiontd y20">20</td><td
class="teamtd s1"><a
href="/football/watford/">Watford</a></td><td
class="numbertd">8</td><td
class="numbertd overalltd mobile_only">0</td><td
class="numbertd overalltd mobile_only">3</td><td
class="numbertd overalltd mobile_only">5</td><td
class="numbertd overalltd mobile_only">4</td><td
class="numbertd overalltd mobile_only">20</td><td
class="numbertd">-16</td><td
class="positiontd"><strong>3 </strong></td></tr><tr><td
class="tablerhs_footer mobile_only" colspan="5"></td><td
class="tablerhs_footer" colspan="5"><a
href="/football/premier-league/table.html">&gt; Full Version</a></td></tr></table></div></div></div><div
class="mpu smExAqH" id="middle_mpu" amp-access="NOT access.adfree"><div
class="GRVAd" data-ad-type="mpu"></div></div><div
class="std_bk1 www rhs eml"><div
class="hw gen_block form_block www rhs eml"><div
class="list_module_header amp css1 www rhs eml"><h3>Subscribe to our Newsletter</h3></div><div
class="sport_top_list news amp www rhs eml"><form
name="submit" method="POST" action-xhr="https://www.sportsmole.co.uk/amp_mail/" target="_top"> <input
type="email" aria-label="type email address" name="email" class="form www rhs eml" placeholder="email@domain.com" value="" required><br
/><div
class="form_div www rhs eml"><input
type="checkbox" id="group_1" name="group_1" value="1" aria-label="Select Transfer Talk" class="av-checkbox www rhs eml" checked="checked"><span
class="form_text www rhs eml">Transfer Talk Daily</span></div><div
class="form_div www rhs eml"><input
type="checkbox" id="group_8" name="group_8" value="1" aria-label="Select Match Previews" class="av-checkbox www rhs eml"><span
class="form_text www rhs eml">Match previews - twice weekly</span></div><div
class="form_div www rhs eml"><input
type="checkbox" aria-label="Morning Briefing" id="group_16" name="group_16" value="1" class="av-checkbox www rhs eml"><span
class="form_text www rhs eml">Morning Briefing (7am UTC)</span></div> <input
type="submit" class="sub www rhs eml" value="Click to subscribe!"> <input
type="hidden" name="ht" value="f32aa524abd11f21b6a58d6ea6e0f6390407433d:MTUxMDMzNjk0Ni43MzI4"> <input
type="hidden" name="mc_signupsource" value="AMPwidget"> <input
type="hidden" name="MERGE7" id="MERGE7" value="AMP Widget mpu"> <input
type="hidden" name="MERGE6" id="MERGE6" value="mpu /football/man-utd/news/"><div
submit-success> <template
type="amp-mustache"><div
class="form_div form_text form_fill norm underTXT www rhs eml"><img
src="https://sm.imgix.net/17/47/gareth-bale-site-design.png?w=82&h=62&auto=compress,format&fit=clip" alt="Close-up shot of Gareth Bale celebrating scoring [NOT SUITABLE FOR ARTICLES]" width="82" height="62" /><span
class="underTXT1 www rhs eml">{{message}}</span></div> </template></div><div
submit-error> <template
type="amp-mustache"> Subscription failed! </template></div><div
class="form_fill norm underTXT www rhs eml"><img
src="https://sm.imgix.net/17/47/kevin-de-bruyne.jpg?w=82&h=62&auto=compress,format&fit=clip" alt="Ultra close-up image of Kevin De Bruyne [NOT FOR USE IN ARTICLES]" width="82" height="62" /><span
class="underTXT1 wP2 www rhs eml">Get the latest transfer news, match previews and news direct to your inbox!</span></div></form></div></div></div><span
amp-access="NOT access.adfree"><div
id="newsnowbottom"></div></span><div
id="twitter_rhs" class="padding-bottom"> <a
class="twitter-timeline" width="300" height="271" data-dnt="true" href="https://twitter.com/sportsmole" data-widget-id="346780441010905089">Tweets by @sportsmole</a></div> <section
amp-access="NOT noq" amp-access-hide> <img
height='0' width='0' alt='' src='//pixel.watch/2y6z' style='display:block;' /> <script data-cfasync="false" class="carambola_InContent" type="text/javascript" cbola_wid="2">(function (i,d,s,o,m,r,c,l,w,q,y,h,g) {  var e=d.getElementById(r);if(e===null){  var t = d.createElement(o); t.src = g; t.id = r; t.setAttribute(m, s);t.async = 1;var n=d.getElementsByTagName(o)[0];n.parentNode.insertBefore(t, n); var dt=new Date().getTime();  try{i[l][w+y](h,i[l][q+y](h)+'&'+dt);}catch(er){i[h]=dt;}  } else if(typeof i[c]!=='undefined'){i[c]++}  else{i[c]=1;}  })(window, document, 'InContent', 'script', 'mediaType', 'carambola_proxy','Cbola_IC','localStorage','set','get','Item','cbolaDt','//route.carambo.la/inimage/getlayer?pid=sprt22&did=110775&wid=2')</script></section> <esi:include src="/esi/217/0/index.html" /><esi:remove><div
id="most_popular_box"><div
class="dbox_outline most_popular"><div
class="dbox_outline_pos most_popular"><div
class="inline-block dbox_outline_line_left most_popular"></div><div
class="inline-block dbox_outline_header most_popular"><a
href="/headlines/">Top Stories</a></div></div></div><div
class="most_popular_tabs"><div
id="top_0_text" onclick="return switchTab(0, 'top_', 3)" class="padding-bottom bold inline-block top_tab tab_selected"> Trending</div><div
id="top_1_text" onclick="return switchTab(1, 'top_', 3)" class="padding-bottom bold inline-block top_tab"> Most Read</div><div
id="top_2_text" onclick="return switchTab(2, 'top_', 3)" class="padding-bottom bold inline-block top_tab"> Most Recent</div></div><div
id="top_0"> <a
href="/football/arsenal/transfer-talk/news/arsenal-to-make-january-bid-for-upamecano_375349.html" title="Arsenal will allegedly reignite their interest in RB Leipzig defender Dayot Upamecano during the January transfer window." class="most_popular_row live_scores_row_odd"><div
class="most_popular_rank"> 1</div> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/06/dayot-upamecano.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="Arsenal to make January bid for Upamecano?" width="52" height="39" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/06/dayot-upamecano.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="Arsenal to make January bid for Upamecano?" width="52" height="39" /></noscript><div
class="most_popular_title"> Arsenal to make January bid for Upamecano?</div> </a><a
href="/football/man-utd/transfer-talk/news/dembele-keen-on-england-return-amid-man-utd-talk_375356.html" title="Lyon forward Moussa Dembele, an alleged target for Manchester United, is reportedly keen to return to England at the end of the season." class="most_popular_row live_scores_row_even"><div
class="most_popular_rank"> 2</div> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/15/moussa-dembele.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="Dembele keen on England return amid Man Utd talk?" width="52" height="39" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/15/moussa-dembele.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="Dembele keen on England return amid Man Utd talk?" width="52" height="39" /></noscript><div
class="most_popular_title"> Dembele keen on England return amid Man Utd talk?</div> </a><a
href="/football/southampton/news/jan-bednarek-angry-southampton-ready-to-respond-against-wolves_375368.html" title="The Saints have lost their last three Premier League matches." class="most_popular_row live_scores_row_odd"><div
class="most_popular_rank"> 3</div> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/42/jan-bednarek.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="Jan Bednarek: 'Angry Southampton ready to respond against Wolves'" width="52" height="39" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/42/jan-bednarek.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="Jan Bednarek: 'Angry Southampton ready to respond against Wolves'" width="52" height="39" /></noscript><div
class="most_popular_title"> Jan Bednarek: 'Angry Southampton ready to respond against Wolves'</div> </a><a
href="/football/spurs/news/quique-sanchez-flores-insists-watford-not-worried-about-league-situation_375369.html" title="The Hornets have yet to win in the Premier League this season." class="most_popular_row live_scores_row_even"><div
class="most_popular_rank"> 4</div> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/40/quique-sanchez-flores.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="Quique Sanchez Flores insists Watford &quot;not worried&quot; about league situation" width="52" height="39" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/40/quique-sanchez-flores.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="Quique Sanchez Flores insists Watford &quot;not worried&quot; about league situation" width="52" height="39" /></noscript><div
class="most_popular_title"> Quique Sanchez Flores insists Watford "not worried" about league situation</div> </a><a
href="/football/man-utd/transfer-talk/news/zidane-meets-with-pogba-in-dubai_375354.html" title="Real Madrid manager Zinedine Zidane meets with Manchester United midfielder Paul Pogba in Dubai during their respective breaks from domestic action." class="most_popular_row live_scores_row_odd"><div
class="most_popular_rank"> 5</div> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/28/paul-pogba.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="Zidane meets with Pogba in Dubai" width="52" height="39" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/28/paul-pogba.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="Zidane meets with Pogba in Dubai" width="52" height="39" /></noscript><div
class="most_popular_title"> Zidane meets with Pogba in Dubai</div> </a><a
href="/football/liverpool/transfer-talk/news/liverpool-willing-to-sell-adam-lallana_375350.html" title="Liverpool are reportedly open to parting ways with Adam Lallana at the end of the season, providing that he does not reclaim his spot back in the starting lineup." class="most_popular_row live_scores_row_even"><div
class="most_popular_rank"> 6</div> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/11/adam-lallana.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="Liverpool willing to sell Adam Lallana?" width="52" height="39" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/11/adam-lallana.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="Liverpool willing to sell Adam Lallana?" width="52" height="39" /></noscript><div
class="most_popular_title"> Liverpool willing to sell Adam Lallana?</div> </a><a
href="/football/chelsea/predicted-lineups/how-chelsea-could-line-up-against-newcastle_375286.html" title="Sports Mole looks at how an injury-hit Chelsea could line up for Saturday's Premier League clash with Newcastle United at Stamford Bridge." class="most_popular_row live_scores_row_odd"><div
class="most_popular_rank"> 7</div> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/41/callum-hudson-odoi.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="How Chelsea could line up against Newcastle" width="52" height="39" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/41/callum-hudson-odoi.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="How Chelsea could line up against Newcastle" width="52" height="39" /></noscript><div
class="most_popular_title"> How Chelsea could line up against Newcastle</div> </a><a
href="/football/man-city/preview/preview-crystal-palace-vs-man-city-prediction-team-news-lineups_375334.html" title="Sports Mole previews Saturday's Premier League clash between Crystal Palace and Manchester City, including predictions and head-to-head records." class="most_popular_row live_scores_row_even"><div
class="most_popular_rank"> 8</div> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/40/pep-guardiola.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="Crystal Palace vs. Man City - prediction, team news, lineups" width="52" height="39" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/40/pep-guardiola.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="Crystal Palace vs. Man City - prediction, team news, lineups" width="52" height="39" /></noscript><div
class="most_popular_title"> Crystal Palace vs. Man City - prediction, team news, lineups</div> </a><a
href="/football/real-madrid/predicted-lineups/how-real-madrid-could-line-up-against-mallorca_375328.html" title="Sports Mole looks at how an injury-hit Real Madrid could line up for Saturday's La Liga contest against newly-promoted Mallorca." class="most_popular_row live_scores_row_odd"><div
class="most_popular_rank"> 9</div> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/40/james-rodriguez.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="How Real Madrid could line up against Mallorca" width="52" height="39" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/40/james-rodriguez.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="How Real Madrid could line up against Mallorca" width="52" height="39" /></noscript><div
class="most_popular_title"> How Real Madrid could line up against Mallorca</div> </a><a
href="/football/man-city/predicted-lineups/how-man-city-could-line-up-against-crystal-palace_375327.html" title="Sports Mole looks at how Manchester City could line up for Saturday's Premier League clash with Crystal Palace at Selhurst Park." class="most_popular_row live_scores_row_even"><div
class="most_popular_rank"> 10</div> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/38/kevin-de-bruyne_1.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="How Man City could line up against Crystal Palace" width="52" height="39" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/38/kevin-de-bruyne_1.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="How Man City could line up against Crystal Palace" width="52" height="39" /></noscript><div
class="most_popular_title"> How Man City could line up against Crystal Palace</div> </a></div><div
id="top_1" class="tab_hidden"> <a
href="/football/chelsea/predicted-lineups/how-chelsea-could-line-up-against-newcastle_375286.html" title="Sports Mole looks at how an injury-hit Chelsea could line up for Saturday's Premier League clash with Newcastle United at Stamford Bridge." class="most_popular_row live_scores_row_odd"><div
class="most_popular_rank"> 1</div> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/41/callum-hudson-odoi.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="How Chelsea could line up against Newcastle" width="52" height="39" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/41/callum-hudson-odoi.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="How Chelsea could line up against Newcastle" width="52" height="39" /></noscript><div
class="most_popular_title"> How Chelsea could line up against Newcastle</div> </a><a
href="/football/barcelona/predicted-lineups/how-barcelona-could-line-up-against-eibar_375265.html" title="Sports Mole looks at how Barcelona could line up for Saturday's La Liga clash with Eibar." class="most_popular_row live_scores_row_even"><div
class="most_popular_rank"> 2</div> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/39/antoine-griezmann.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="How Barcelona could line up against Eibar" width="52" height="39" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/39/antoine-griezmann.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="How Barcelona could line up against Eibar" width="52" height="39" /></noscript><div
class="most_popular_title"> How Barcelona could line up against Eibar</div> </a><a
href="/football/juventus/predicted-lineups/how-juventus-could-line-up-against-bologna_375271.html" title="Sports Mole looks at how Juventus could line up for Saturday's Serie A clash with Bologna." class="most_popular_row live_scores_row_odd"><div
class="most_popular_rank"> 3</div> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/40/cristiano-ronaldo.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="How Juventus could line up against Bologna" width="52" height="39" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/40/cristiano-ronaldo.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="How Juventus could line up against Bologna" width="52" height="39" /></noscript><div
class="most_popular_title"> How Juventus could line up against Bologna</div> </a><a
href="/football/barcelona/preview/preview-eibar-vs-barcelona-prediction-team-news-lineups_375281.html" title="Sports Mole previews Saturday's La Liga clash between Eibar and Barcelona, including predictions, team news and possible lineups." class="most_popular_row live_scores_row_even"><div
class="most_popular_rank"> 4</div> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/40/luis-suarez.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="Eibar vs. Barcelona - prediction, team news, lineups" width="52" height="39" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/40/luis-suarez.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="Eibar vs. Barcelona - prediction, team news, lineups" width="52" height="39" /></noscript><div
class="most_popular_title"> Eibar vs. Barcelona - prediction, team news, lineups</div> </a><a
href="/football/real-madrid/predicted-lineups/how-real-madrid-could-line-up-against-mallorca_375328.html" title="Sports Mole looks at how an injury-hit Real Madrid could line up for Saturday's La Liga contest against newly-promoted Mallorca." class="most_popular_row live_scores_row_odd"><div
class="most_popular_rank"> 5</div> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/40/james-rodriguez.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="How Real Madrid could line up against Mallorca" width="52" height="39" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/40/james-rodriguez.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="How Real Madrid could line up against Mallorca" width="52" height="39" /></noscript><div
class="most_popular_title"> How Real Madrid could line up against Mallorca</div> </a><a
href="/football/chelsea/preview/preview-chelsea-vs-newcastle-prediction-team-news-lineups_375244.html" title="Sports Mole provides team news, predicted lineups and a full preview of Saturday's Premier League fixture between Chelsea and Newcastle United." class="most_popular_row live_scores_row_even"><div
class="most_popular_rank"> 6</div> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/40/frank-lampard_1.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="Chelsea vs. Newcastle - prediction, team news, lineups" width="52" height="39" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/40/frank-lampard_1.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="Chelsea vs. Newcastle - prediction, team news, lineups" width="52" height="39" /></noscript><div
class="most_popular_title"> Chelsea vs. Newcastle - prediction, team news, lineups</div> </a><a
href="/football/man-city/predicted-lineups/how-man-city-could-line-up-against-crystal-palace_375327.html" title="Sports Mole looks at how Manchester City could line up for Saturday's Premier League clash with Crystal Palace at Selhurst Park." class="most_popular_row live_scores_row_odd"><div
class="most_popular_rank"> 7</div> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/38/kevin-de-bruyne_1.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="How Man City could line up against Crystal Palace" width="52" height="39" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/38/kevin-de-bruyne_1.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="How Man City could line up against Crystal Palace" width="52" height="39" /></noscript><div
class="most_popular_title"> How Man City could line up against Crystal Palace</div> </a><a
href="/football/man-city/preview/preview-crystal-palace-vs-man-city-prediction-team-news-lineups_375334.html" title="Sports Mole previews Saturday's Premier League clash between Crystal Palace and Manchester City, including predictions and head-to-head records." class="most_popular_row live_scores_row_even"><div
class="most_popular_rank"> 8</div> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/40/pep-guardiola.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="Crystal Palace vs. Man City - prediction, team news, lineups" width="52" height="39" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/40/pep-guardiola.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="Crystal Palace vs. Man City - prediction, team news, lineups" width="52" height="39" /></noscript><div
class="most_popular_title"> Crystal Palace vs. Man City - prediction, team news, lineups</div> </a><a
href="/football/real-madrid/preview/preview-mallorca-vs-real-madrid-prediction-team-news-lineups_375314.html" title="Sports Mole previews the La Liga clash between Mallorca and Real Madrid at the Estadi de Son Moix, including predictions, team news and possible lineups." class="most_popular_row live_scores_row_odd"><div
class="most_popular_rank"> 9</div> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/39/zinedine-zidane.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="Mallorca vs. Real Madrid - prediction, team news, lineups" width="52" height="39" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/39/zinedine-zidane.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="Mallorca vs. Real Madrid - prediction, team news, lineups" width="52" height="39" /></noscript><div
class="most_popular_title"> Mallorca vs. Real Madrid - prediction, team news, lineups</div> </a><a
href="/football/real-madrid/el-clasico/news/el-clasico-to-be-postponed-for-two-months_375316.html" title="The first El Clasico of the season could be postponed until December amid ongoing security issues, according to a report." class="most_popular_row live_scores_row_even"><div
class="most_popular_rank"> 10</div> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/09/rmabar_6.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="El Clasico to be postponed for two months?" width="52" height="39" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/09/rmabar_6.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="El Clasico to be postponed for two months?" width="52" height="39" /></noscript><div
class="most_popular_title"> El Clasico to be postponed for two months?</div> </a></div><div
id="top_2" class="tab_hidden"> <a
href="/football/man-utd/sack-race/news/ole-gunnar-solskjaer-manchester-united-job-is-not-too-big-for-me_375374.html" title="United enter the weekend two points off the relegation zone." class="most_popular_row live_scores_row_odd"><div
class="most_popular_rank"> 1</div> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/41/ole-gunnar-solskjaer.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="Ole Gunnar Solskjaer: 'Manchester United job is not too big for me'" width="52" height="39" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/41/ole-gunnar-solskjaer.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="Ole Gunnar Solskjaer: 'Manchester United job is not too big for me'" width="52" height="39" /></noscript><div
class="most_popular_title"> Ole Gunnar Solskjaer: 'Manchester United job is not too big for me'</div> </a><a
href="/football/kilmarnock/news/simeon-jackson-reveals-feisty-first-training-session-at-killie_375375.html" title="The forward, who has signed a short-term deal, was on the receiving end of a crunching challenge from Alan Power early in his first training session." class="most_popular_row live_scores_row_even"><div
class="most_popular_rank"> 2</div> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/11/rugby-park-kilmarnock.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="Simeon Jackson reveals feisty first training session at Killie" width="52" height="39" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/11/rugby-park-kilmarnock.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="Simeon Jackson reveals feisty first training session at Killie" width="52" height="39" /></noscript><div
class="most_popular_title"> Simeon Jackson reveals feisty first training session at Killie</div> </a><a
href="/football/burnley/news/sean-dyche-looking-to-build-on-burnleys-solid-start_375372.html" title="The Clarets are currently seventh in the Premier League table." class="most_popular_row live_scores_row_odd"><div
class="most_popular_rank"> 3</div> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/39/sean-dyche.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="Sean Dyche looking to build on Burnley's &quot;solid start&quot;" width="52" height="39" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/39/sean-dyche.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="Sean Dyche looking to build on Burnley's &quot;solid start&quot;" width="52" height="39" /></noscript><div
class="most_popular_title"> Sean Dyche looking to build on Burnley's "solid start"</div> </a><a
href="/football/arsenal/racism-in-football/news/unai-emery-confident-uefa-can-tackle-racist-abuse-problem_375371.html" title="The Arsenal manager said it is the responsibility of everyone in football to bring an end to racism." class="most_popular_row live_scores_row_even"><div
class="most_popular_rank"> 4</div> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/40/unai-emery.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="Unai Emery confident UEFA can tackle racist abuse problem" width="52" height="39" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/40/unai-emery.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="Unai Emery confident UEFA can tackle racist abuse problem" width="52" height="39" /></noscript><div
class="most_popular_title"> Unai Emery confident UEFA can tackle racist abuse problem</div> </a><a
href="/football/hamilton-academical/news/hibernian-striker-florian-kamberi-admits-he-is-not-happy_375367.html" title="The former Grasshopper marksman has five goals to his name in all competitions so far this campaign." class="most_popular_row live_scores_row_odd"><div
class="most_popular_rank"> 5</div> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/12/39/640x480_SMlogo.jpg?w=52&h=39" alt="Hibernian striker Florian Kamberi admits he is &quot;not happy&quot;" width="52" height="39" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/12/39/640x480_SMlogo.jpg?w=52&h=39" alt="Hibernian striker Florian Kamberi admits he is &quot;not happy&quot;" width="52" height="39" /></noscript><div
class="most_popular_title"> Hibernian striker Florian Kamberi admits he is "not happy"</div> </a><a
href="/football/southampton/news/jan-bednarek-angry-southampton-ready-to-respond-against-wolves_375368.html" title="The Saints have lost their last three Premier League matches." class="most_popular_row live_scores_row_even"><div
class="most_popular_rank"> 6</div> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/42/jan-bednarek.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="Jan Bednarek: 'Angry Southampton ready to respond against Wolves'" width="52" height="39" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/42/jan-bednarek.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="Jan Bednarek: 'Angry Southampton ready to respond against Wolves'" width="52" height="39" /></noscript><div
class="most_popular_title"> Jan Bednarek: 'Angry Southampton ready to respond against Wolves'</div> </a><a
href="/football/spurs/news/quique-sanchez-flores-insists-watford-not-worried-about-league-situation_375369.html" title="The Hornets have yet to win in the Premier League this season." class="most_popular_row live_scores_row_odd"><div
class="most_popular_rank"> 7</div> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/40/quique-sanchez-flores.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="Quique Sanchez Flores insists Watford &quot;not worried&quot; about league situation" width="52" height="39" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/40/quique-sanchez-flores.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="Quique Sanchez Flores insists Watford &quot;not worried&quot; about league situation" width="52" height="39" /></noscript><div
class="most_popular_title"> Quique Sanchez Flores insists Watford "not worried" about league situation</div> </a><a
href="/football/leicester-city/news/brendan-rodgers-pays-tribute-to-vichai-ahead-of-anniversary-of-tragedy_375370.html" title="Tributes will be paid to their former chairman on Saturday." class="most_popular_row live_scores_row_even"><div
class="most_popular_rank"> 8</div> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/18/44/vichai-srivaddhanaprabha.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="Brendan Rodgers pays tribute to Vichai ahead of anniversary of tragedy" width="52" height="39" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/18/44/vichai-srivaddhanaprabha.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="Brendan Rodgers pays tribute to Vichai ahead of anniversary of tragedy" width="52" height="39" /></noscript><div
class="most_popular_title"> Brendan Rodgers pays tribute to Vichai ahead of anniversary of tragedy</div> </a><a
href="/football/aberdeen/news/niall-mcginn-win-or-lose-always-a-positive-mood-at-aberdeen_375365.html" title="The Dons are fourth in the Scottish Premiership standings." class="most_popular_row live_scores_row_odd"><div
class="most_popular_rank"> 9</div> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/12/niall-mcginn.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="Niall McGinn: 'Win or lose, always a positive mood at Aberdeen'" width="52" height="39" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/12/niall-mcginn.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="Niall McGinn: 'Win or lose, always a positive mood at Aberdeen'" width="52" height="39" /></noscript><div
class="most_popular_title"> Niall McGinn: 'Win or lose, always a positive mood at Aberdeen'</div> </a><a
href="/football/motherwell/news/stephen-robinson-praises-well-defender-declan-gallagher_375366.html" title="The defender received his first Scotland call-up during the international break." class="most_popular_row live_scores_row_even"><div
class="most_popular_rank"> 10</div> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/18/50/stephen-robinson.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="Stephen Robinson praises Well defender Declan Gallagher" width="52" height="39" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/18/50/stephen-robinson.jpg?w=52&h=39&auto=compress,format&fit=clip" alt="Stephen Robinson praises Well defender Declan Gallagher" width="52" height="39" /></noscript><div
class="most_popular_title"> Stephen Robinson praises Well defender Declan Gallagher</div> </a></div><div
class="most_popular_footer bold"><a
href="/headlines/">&gt; View all headlines</a></div></div><span
class="hidden">NO ESI</span></esi:remove> <span
amp-access="NOT access.adfree"><div
class="left mpu smExAqH" id="amazon_mpu" amp-access="NOT access.adfree"><div
class="GRVAd" data-ad-type="mpu" data-ad-sizes='[[300,250]]' data-ad-inView="true"></div></div></span> <span
amp-access="NOT access.adfree"><div
id="app_net_promo" class="left margin-bottom smExAqH" amp-access="NOT access.adfree"><div
class="GRVAd" data-ad-type="mpu" data-ad-sizes='[[300,250]]' data-ad-inView="true"></div></div></span><div
id="ff-competitions-widget-2"></div> <span
amp-access="NOT access.adfree"><span
amp-access="NOT access.adfree"><div
id="rcjsload_429b60"></div><script type="text/javascript">(function() {var referer="";try{if(referer=document.referrer,"undefined"==typeof referer||""==referer)throw"undefined"}catch(exception){referer=document.location.href,(""==referer||"undefined"==typeof referer)&&(referer=document.URL)}referer=referer.substr(0,700);var rcds = document.getElementById("rcjsload_429b60");var rcel = document.createElement("script");rcel.id = 'rc_' + Math.floor(Math.random() * 1000);rcel.type = 'text/javascript';rcel.src = "https://trends.revcontent.com/serve.js.php?w=92672&t="+rcel.id+"&c="+(new Date()).getTime()+"&width="+(window.outerWidth || document.documentElement.clientWidth)+"&referer="+referer;rcel.async = true;rcds.appendChild(rcel);})();</script></span></span> <span
amp-access="NOT access.adfree"><div
class="clearB w100"><div
class="mAuto center"><amp-embed
width="100" height="100" type="taboola" layout="responsive" heights="(min-width:1684px) 425%, (min-width:1341px) 431%, (min-width:1092px) 439%, (min-width:889px) 448%, (min-width:728px) 458%, (min-width:597px) 471%, (min-width:514px) 487%, (min-width:445px) 506%, (min-width:386px) 529%, 555%" data-publisher="sportsmole1" data-mode="thumbnails-a-amp" data-placement="Mobile Below Article Thumbnails AMP" data-target_type="mix" data-article="auto" data-url=""></amp-embed></div><div
class="mAuto center AdTablet970"><amp-embed
width="100" height="100" type="taboola" layout="responsive" heights="(min-width:1680px) 58%,  (min-width:1214px)  64%, (min-width:879px) 72%,   (min-width:628px) 83%,  (min-width:450px) 99%, 121%" data-publisher="sportsmole1" data-mode="thumbnails-d-amp"    data-placement="Mobile Below Article Thumbnails AMP 4x2" data-target_type="mix" data-article="auto" data-url=""></amp-embed></div><div
class="mAuto center AdTablet468"><amp-embed
width="100" height="100" type="taboola" layout="responsive" heights="(min-width:1694px) 72%, (min-width:1221px) 78%,(min-width:883px) 86%, (min-width:630px) 97%,(min-width:452px) 113%, 135%" data-publisher="sportsmole1" data-mode="thumbnails-c-amp" data-placement="Mobile Below Article Thumbnails AMP 3x2" data-target_type="mix" data-article="auto" data-url=""></amp-embed></div></div> </span> <span
amp-access="NOT access.adfree"><div
class="mpu smExAqH" id="media_net" amp-access="NOT access.adfree"><div
class="GRVAd" data-ad-type="mpu" data-ad-sizes='[[300,250]]' data-ad-inView="true"></div></div></span></div><div
class="clearboth"></div></div> <span
class="smExAqH" amp-access="NOT access.adfree"><div
class="GRVAd" data-ad-type="leaderboard" data-ad-sizeMapping="leaderboardNoBillboard" data-ad-inView="true"></div></span> <span
class="smExAqH" amp-access="NOT access.adfree"><span
class="8trkQ"></span></span> <esi:include src="/esi/1330/0/index.html" /><esi:remove><div
id="footer"><div
class="footer_links_wrapper footer_links"> <img
class="lazy footer_bg" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://d1sew2ts8kb61y.cloudfront.net/12/46/footer_grass.jpg?w=980&h=290" alt="Footer Grass" width="980" height="290" /><noscript><img
class="footer_bg" src="https://d1sew2ts8kb61y.cloudfront.net/12/46/footer_grass.jpg?w=980&h=290" alt="Footer Grass" width="980" height="290" /></noscript><div
id="footercell1" class="footercell"> <a
class="footer_strong" href="/football/">Football</a> <a
href="/football/news/">Football News</a> <a
href="/football/live-scores/">Fixtures &amp; Results</a> <a
href="/football/preview/">Previews</a> <a
href="/football/live-commentary/">Live Commentaries</a> <a
href="/football/transfer-talk/">Transfer Talk</a> <span
class="footer_strong footer_block">Leagues</span> <a
href="/football/premier-league/">Premier League</a> <a
href="/football/championship/">Championship</a> <a
href="/football/league-one/">League One</a> <a
href="/football/league-two/">League Two</a> <a
href="/football/la-liga/">La Liga</a> <a
href="/football/bundesliga/">Bundesliga</a> <a
href="/football/serie-a/">Serie A</a> <a
href="/football/ligue-1/">Ligue 1</a> <a
href="/football/scottish-premiership/">Scottish Premiership</a></div><div
id="footercell2" class="footercell"> <a
class="footer_strong" href="/tennis/">Tennis</a> <a
href="/tennis/news/">Tennis News</a> <a
href="/tennis/result/">Results</a> <a
href="/tennis/atp-mens-world-rankings.html">ATP Rankings</a> <a
href="/tennis/wta-womens-world-rankings.html">WTA Rankings</a> <a
class="footer_strong footer_block" href="/rugby-union/">Rugby Union</a> <a
href="/rugby-union/news/">Rugby U News</a> <a
href="/rugby-union/result/">Results</a> <a
href="/rugby-union/aviva-premiership/table.html">Aviva Premiership Table</a> <a
class="footer_strong footer_block" href="/rugby-league/">Rugby League</a> <a
href="/rugby-league/news/">Rugby L News</a> <a
href="/rugby-league/result/">Results</a> <a
href="/rugby-league/super-league/table.html">Super League Table</a> <a
class="footer_strong footer_block" href="/sw3/"><small>Sports news on the web</small></a></div><div
id="footercell3" class="footercell"> <a
class="footer_strong" href="/cricket/">Cricket</a> <a
href="/cricket/news/">Cricket News</a> <a
href="/cricket/live-commentary/">Live Commentaries</a> <a
class="footer_strong footer_block" href="/formula-1/">Formula 1</a> <a
href="/formula-1/news/">F1 News</a> <a
href="/formula-1/live-commentary/">Live Commentaries</a> <a
href="/formula-1/driver-rankings.html">Drivers Rankings</a> <a
href="/formula-1/team-rankings.html">Team Rankings</a> <a
class="footer_strong footer_block" href="/golf/">Golf</a> <a
class="footer_strong" href="/boxing/">Boxing</a> <a
class="footer_strong" href="/cycling/">Cycling</a> <a
class="footer_strong" href="/athletics/">Athletics</a> <a
class="footer_strong" href="/american-football/">NFL</a> <a
class="footer_strong" href="/more-sports/">More Sports</a> <a
class="footer_strong" href="/off-the-pitch/">Off The Pitch</a></div><div
id="footercell4" class="footercell"> <a
class="footer_strong" href="/">Sports Mole</a> <a
href="/about/">About Sports Mole</a> <a
href="/about/advertise/">Advertising</a> <a
href="/about/faqs/">Sports Mole FAQs</a> <a
href="/about/team/">Meet The Team</a> <a
href="/about/contact/">Contact Us</a> <a
href="/about/newsletter/">Newsletter</a> <a
class="footer_block" href="/about/jobs/">Jobs with SM</a> <a
href="/about/competitions/">Competitions</a> <a
href="https://games.sportsmole.co.uk/">Play Games</a> <a
class="footer_block" href="https://www.facebook.com/sportsmole/">SM on Facebook</a> <a
href="https://www.twitter.com/sportsmole/">SM on Twitter</a> <a
href="https://instagram.com/sportsmole">SM on Instagram</a> <a
href="https://www.linkedin.com/company/sports-mole">SM on LinkedIn</a> <a
href="https://youtube.com/sportsmolevideo">SM on YouTube</a> <a
href="https://soundcloud.com/sportsmole">SM on SoundCloud</a></div><div
class="center2 white w100"><br
/><a
class="footer_strong" href="https://www.sportsmole.co.uk/?grva_cmp=true&grva_cmp_open=true">Change your cookie settings</a></div></div><div
id="copyright"> &copy; 2011- Sports Mole Ltd. All rights reserved. <a
href="/about/terms/">Terms &amp; Conditions</a> | <a
href="/about/privacy/">Privacy Policy</a> | <a
href="/about/information/how-and-why-does-sports-mole-use-cookies_28868.html">Cookies Policy</a></div></div><span
class="hidden">NO ESI</span></esi:remove>  <script>console.log('bottom of page reached - www - desktop');</script> <div
class="mpu smExAqH" id="top_mpu" amp-access="NOT access.adfree"><div
class="GRVAd" data-ad-type="primary-leaderboard" data-ad-sizeMapping="leaderboardNoBillboard" data-ad-fixedMapping="leaderboard" data-ad-refreshMapping="always"></div></div><div
id="subnav_hover"><div
id="subnav_headlines" class="subnav"><div
class="subnav_trending"><h2>Latest Headlines</h2><a
href="/football/man-utd/sack-race/news/ole-gunnar-solskjaer-manchester-united-job-is-not-too-big-for-me_375374.html" title="United enter the weekend two points off the relegation zone." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/41/ole-gunnar-solskjaer.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Manchester United manager Ole Gunnar Solskjaer pictured on October 6, 2019" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/41/ole-gunnar-solskjaer.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Manchester United manager Ole Gunnar Solskjaer pictured on October 6, 2019" width="124" height="93" /></noscript><div
class="trending_title"> Ole Gunnar Solskjaer: 'Manchester United job is not too big for me'</div> </a><a
href="/football/kilmarnock/news/simeon-jackson-reveals-feisty-first-training-session-at-killie_375375.html" title="The forward, who has signed a short-term deal, was on the receiving end of a crunching challenge from Alan Power early in his first training session." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/11/rugby-park-kilmarnock.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="General view of Rugby Park, home to Kilmarnock, from 2011" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/11/rugby-park-kilmarnock.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="General view of Rugby Park, home to Kilmarnock, from 2011" width="124" height="93" /></noscript><div
class="trending_title"> Simeon Jackson reveals feisty first training session at Killie</div> </a><a
href="/football/burnley/news/sean-dyche-looking-to-build-on-burnleys-solid-start_375372.html" title="The Clarets are currently seventh in the Premier League table." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/39/sean-dyche.jpg?w=124&h=93&auto=compress,format&fit=clip" alt=" Burnley boss Sean Dyche remonstrates on September 28, 2019" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/39/sean-dyche.jpg?w=124&h=93&auto=compress,format&fit=clip" alt=" Burnley boss Sean Dyche remonstrates on September 28, 2019" width="124" height="93" /></noscript><div
class="trending_title"> Sean Dyche looking to build on Burnley's "solid start"</div> </a><a
href="/football/arsenal/racism-in-football/news/unai-emery-confident-uefa-can-tackle-racist-abuse-problem_375371.html" title="The Arsenal manager said it is the responsibility of everyone in football to bring an end to racism." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/40/unai-emery.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Arsenal boss Unai Emery pictured on October 3, 2019" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/40/unai-emery.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Arsenal boss Unai Emery pictured on October 3, 2019" width="124" height="93" /></noscript><div
class="trending_title"> Unai Emery confident UEFA can tackle racist abuse problem</div> </a><a
href="/football/hamilton-academical/news/hibernian-striker-florian-kamberi-admits-he-is-not-happy_375367.html" title="The former Grasshopper marksman has five goals to his name in all competitions so far this campaign." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/12/39/640x480_SMlogo.jpg?w=124&h=93" alt="Sports Mole logo" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/12/39/640x480_SMlogo.jpg?w=124&h=93" alt="Sports Mole logo" width="124" height="93" /></noscript><div
class="trending_title"> Hibernian striker Florian Kamberi admits he is "not happy"</div> </a><a
href="/football/southampton/news/jan-bednarek-angry-southampton-ready-to-respond-against-wolves_375368.html" title="The Saints have lost their last three Premier League matches." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/42/jan-bednarek.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Jan Bednarek in action for Southampton on September 20, 2019" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/42/jan-bednarek.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Jan Bednarek in action for Southampton on September 20, 2019" width="124" height="93" /></noscript><div
class="trending_title"> Jan Bednarek: 'Angry Southampton ready to respond against Wolves'</div> </a></div><div
class="l_a" title="New articles on Sports Mole"><span
class="Left vm2">119 <a
href="/headlines/" title="Latest Headline listed cronologically" class="bold">new articles</a> in last day;&nbsp</span><span
class="Right vm2"><a
href="/football/man-utd/sack-race/news/ole-gunnar-solskjaer-manchester-united-job-is-not-too-big-for-me_375374.html" title="The most recently published article" class="norm">last new at 11:53</a></span></div></div><div
id="subnav_football" class="subnav"><div
class="more_left"><div
class="subnav_col"> <strong>Explore Football</strong> <a
href="/football/news/">News</a> <a
href="/football/live-scores/">Fixtures &amp; Results</a> <a
href="/football/premier-league/table.html">League Tables</a> <a
href="/football/premier-league/2019-20/">Stat Centre</a> <a
href="/football/preview/">Previews</a> <a
href="/football/live-commentary/">Live Commentaries</a> <a
href="/football/feature/">Features</a> <a
class="last_subnav" href="/football/transfer-talk/">Transfer Talk</a></div><div
class="subnav_col desktop_only"> <strong>Competitions</strong> <a
href="/football/premier-league/">Premier League</a> <a
href="/football/championship/">Championship</a> <a
href="/football/champions-league/">Champions League</a> <a
href="/football/scottish-premiership/">Scottish Premiership</a> <a
href="/football/la-liga/">La Liga</a> <a
href="/football/bundesliga/">Bundesliga</a> <a
href="/football/serie-a/">Serie A</a> <a
href="/football/ligue-1/">Ligue 1</a></div><div
class="subnav_col desktop_only"> <strong>Popular Teams</strong> <a
href="/football/man-utd/">Manchester United</a> <a
href="/football/liverpool/">Liverpool</a> <a
href="/football/arsenal/">Arsenal</a> <a
href="/football/chelsea/">Chelsea</a> <a
href="/football/spurs/">Tottenham Hotspur</a> <a
href="/football/man-city/">Manchester City</a> <a
href="/football/barcelona/">Barcelona</a> <a
href="/football/real-madrid/">Real Madrid</a></div></div><div
class="subnav_trending"><h2>Trending Football Stories</h2> <a
href="/football/man-utd/sack-race/news/ed-woodward-reiterates-ole-gunnar-solskjaer-support_375325.html" title="Manchester United are in the midst of their worst start to a season in 30 years." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/41/ole-gunnar-solskjaer.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Manchester United manager Ole Gunnar Solskjaer pictured on October 6, 2019" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/41/ole-gunnar-solskjaer.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Manchester United manager Ole Gunnar Solskjaer pictured on October 6, 2019" width="124" height="93" /></noscript><div
class="trending_title"> Ed Woodward reiterates Ole Gunnar Solskjaer support</div> </a><a
href="/football/cardiff-city/preview/preview-cardiff-vs-sheffield-wednesday-prediction-team-news-lineups_375166.html" title="Sports Mole previews Cardiff City's clash with Sheffield Wednesday in the Championship on Friday, including predictions, team news and predicted lineups." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/20/neil-warnock.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Calm and composed Cardiff manager Neil Warnock pictured on May 12, 2019" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/20/neil-warnock.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Calm and composed Cardiff manager Neil Warnock pictured on May 12, 2019" width="124" height="93" /></noscript><div
class="trending_title"> Preview: Cardiff vs. Sheffield Wednesday - prediction, team news, lineups</div> </a><a
href="/football/man-utd/sack-race/news/ole-gunnar-solskjaer-manchester-united-job-is-not-too-big-for-me_375374.html" title="United enter the weekend two points off the relegation zone." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/41/ole-gunnar-solskjaer.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Manchester United manager Ole Gunnar Solskjaer pictured on October 6, 2019" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/41/ole-gunnar-solskjaer.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Manchester United manager Ole Gunnar Solskjaer pictured on October 6, 2019" width="124" height="93" /></noscript><div
class="trending_title"> Ole Gunnar Solskjaer: 'Manchester United job is not too big for me'</div> </a></div></div><div
id="subnav_football-transfer-talk" class="subnav"><div
class="more_left"><div
class="subnav_col"> <strong>Explore Transfer Talk</strong> <a
href="/football/transfer-talk/">All</a> <a
href="/football/transfer-talk/rumours/">Rumours</a> <a
href="/football/transfer-talk/done-deals/">Done Deals</a> <a
class="last_subnav" href="/football/transfer-talk/new-contracts/">New Contracts</a></div></div><div
class="subnav_trending"><h2>Transfer Talk</h2><a
href="/football/man-utd/transfer-talk/news/dembele-keen-on-england-return-amid-man-utd-talk_375356.html" title="Lyon forward Moussa Dembele, an alleged target for Manchester United, is reportedly keen to return to England at the end of the season." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/15/moussa-dembele.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Lyon forward Moussa Dembele in action in March, 2019" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/15/moussa-dembele.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Lyon forward Moussa Dembele in action in March, 2019" width="124" height="93" /></noscript><div
class="trending_title"> Dembele keen on England return amid Man Utd talk?</div> </a><a
href="/football/man-utd/transfer-talk/news/zidane-meets-with-pogba-in-dubai_375354.html" title="Real Madrid manager Zinedine Zidane meets with Manchester United midfielder Paul Pogba in Dubai during their respective breaks from domestic action." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/28/paul-pogba.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Paul Pogba in Premier League action for Manchester United on May 12, 2019" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/28/paul-pogba.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Paul Pogba in Premier League action for Manchester United on May 12, 2019" width="124" height="93" /></noscript><div
class="trending_title"> Zidane meets with Pogba in Dubai</div> </a><a
href="/football/man-utd/transfer-talk/news/inter-to-offer-matic-man-utd-escape-route_375351.html" title="Inter Milan are reportedly contemplating a January approach for Manchester United midfielder Nemanja Matic." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/18/41/nemanja-matic.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Nemanja Matic in action for Manchester United in the Champions League on September 19, 2018" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/18/41/nemanja-matic.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Nemanja Matic in action for Manchester United in the Champions League on September 19, 2018" width="124" height="93" /></noscript><div
class="trending_title"> Inter to offer Matic Man Utd escape route?</div> </a><a
href="/football/liverpool/transfer-talk/news/liverpool-willing-to-sell-adam-lallana_375350.html" title="Liverpool are reportedly open to parting ways with Adam Lallana at the end of the season, providing that he does not reclaim his spot back in the starting lineup." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/11/adam-lallana.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Adam Lallana in action for Liverpool on March 17, 2019" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/11/adam-lallana.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Adam Lallana in action for Liverpool on March 17, 2019" width="124" height="93" /></noscript><div
class="trending_title"> Liverpool willing to sell Adam Lallana?</div> </a><a
href="/football/arsenal/transfer-talk/news/arsenal-to-make-january-bid-for-upamecano_375349.html" title="Arsenal will allegedly reignite their interest in RB Leipzig defender Dayot Upamecano during the January transfer window." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/06/dayot-upamecano.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Dayot Upamecano pictured in October 2018" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/06/dayot-upamecano.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Dayot Upamecano pictured in October 2018" width="124" height="93" /></noscript><div
class="trending_title"> Arsenal to make January bid for Upamecano?</div> </a></div></div><div
id="subnav_tennis" class="subnav"><div
class="more_left"><div
class="subnav_col"> <strong>Explore Tennis</strong> <a
href="/tennis/news/">News</a> <a
href="/tennis/result/">Results</a> <a
href="/tennis/atp-mens-world-rankings.html">ATP Rankings</a> <a
href="/tennis/wta-womens-world-rankings.html">WTA Rankings</a> <a
href="/tennis/australian-open/">Australian Open</a> <a
href="/tennis/french-open">French Open</a> <a
href="/tennis/wimbledon/">Wimbledon</a> <a
href="/tennis/us-open/">US Open</a></div><div
class="subnav_col subnav_dropdown last_subnav"> <strong
class="last_subnav">Popular Players</strong> <a
href="/people/rafael-nadal/">Rafael Nadal</a> <a
href="/people/andy-murray/">Andy Murray</a> <a
href="/people/novak-djokovic/">Novak Djokovic</a> <a
href="/people/roger-federer/">Roger Federer</a> <a
class="last_subnav" href="/people/serena-williams/">Serena Williams</a></div></div><div
class="subnav_trending"><h2>Trending Tennis Stories</h2> <a
href="/tennis/result/result-andy-murray-books-quarter-final-spot-in-antwerp_375310.html" title="The Scot is into the last eight." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/41/andy-murray.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Andy Murray pictured on October 4, 2019" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/41/andy-murray.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Andy Murray pictured on October 4, 2019" width="124" height="93" /></noscript><div
class="trending_title"> Result: Andy Murray books quarter-final spot in Antwerp</div> </a><a
href="/tennis/news/greg-rusedski-warns-andy-murray-he-still-has-a-long-road-to-recovery_375248.html" title="Murray is playing in Antwerp this week after a successful three weeks in China." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/41/andy-murray.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Andy Murray pictured on October 4, 2019" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/41/andy-murray.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Andy Murray pictured on October 4, 2019" width="124" height="93" /></noscript><div
class="trending_title"> Greg Rusedski warns Andy Murray he still has a long road to recovery</div> </a><a
href="/tennis/result/result-andy-murray-wins-first-atp-tour-match-for-16-months_375114.html" title="The Scot saw off Belgian Kimmer Coppejans, the world number 158, in straight sets." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/41/andy-murray.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Andy Murray pictured on October 4, 2019" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/41/andy-murray.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Andy Murray pictured on October 4, 2019" width="124" height="93" /></noscript><div
class="trending_title"> Result: Andy Murray wins first ATP Tour match for 16 months</div> </a><a
href="/tennis/result/result-fifteen-year-old-coco-gauff-wins-maiden-wta-title_374896.html" title="The American triumphed at the Upper Austria Ladies Linz having entered the main draw as a lucky loser." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/41/coco-gauff.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Coco Gauff pictured in September 2019" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/41/coco-gauff.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Coco Gauff pictured in September 2019" width="124" height="93" /></noscript><div
class="trending_title"> Result: Fifteen-year-old Coco Gauff wins maiden WTA title</div> </a></div></div><div
id="subnav_rugby-union" class="subnav"><div
class="more_left"><div
class="subnav_col"> <strong>Explore Rugby Union</strong> <a
href="/rugby-union/news/">News</a> <a
href="/rugby-union/result/">Results</a> <a
href="/rugby-union/six-nations/">Six Nations</a> <a
href="/rugby-union/england/">England News</a> <a
href="/rugby-union/aviva-premiership/">Aviva Premiership</a> <a
href="/rugby-union/aviva-premiership/table.html">AP Table</a> <a
class="last_subnav" href="/rugby-union/rugby-world-cup/">Rugby World Cup</a></div></div><div
class="subnav_trending"><h2>Trending Rugby Union Stories</h2> <a
href="/rugby-union/wales/rugby-world-cup/feature/wales-vs-france-the-recent-record_375358.html" title="France edged to a 9-8 win in Auckland eight years ago." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/40/rhys-patchell.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Rhys Patchell in action for Wales on September 29, 2019" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/40/rhys-patchell.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Rhys Patchell in action for Wales on September 29, 2019" width="124" height="93" /></noscript><div
class="trending_title"> Wales vs. France: The recent record</div> </a><a
href="/rugby-union/australia/rugby-world-cup/feature/in-pictures-england-vs-australia-over-the-last-110-years_375346.html" title="Eddie Jones is aiming to secure his seventh successive victory over Australia as England head coach." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/40/eddie-jones.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="England boss Eddie Jones pictured on September 22, 2019" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/40/eddie-jones.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="England boss Eddie Jones pictured on September 22, 2019" width="124" height="93" /></noscript><div
class="trending_title"> In pictures: England vs. Australia over the last 110 years</div> </a><a
href="/rugby-union/ireland/rugby-world-cup/news/johnny-sexton-warns-nz-about-strong-arm-tactics-against-ireland_375359.html" title="The Irish playmaker thinks two New Zealand players avoided red cards in Dublin three years ago." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/41/johnny-sexton.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Johnny Sexton scores for Ireland on October 12, 2019" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/41/johnny-sexton.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Johnny Sexton scores for Ireland on October 12, 2019" width="124" height="93" /></noscript><div
class="trending_title"> Johnny Sexton warns NZ about strong-arm tactics against Ireland</div> </a><a
href="/rugby-union/england/rugby-world-cup/news/ben-youngs-england-will-fight-until-the-end-against-australia_375344.html" title="England are on a six-match winning run against Australia" class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/11/ben-youngs.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Ben Youngs warms up for England on March 9, 2019" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/11/ben-youngs.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Ben Youngs warms up for England on March 9, 2019" width="124" height="93" /></noscript><div
class="trending_title"> Ben Youngs: 'England will fight until the end against Australia'</div> </a><a
href="/rugby-union/france/news/warren-gatland-insists-dan-biggar-is-fully-fit-for-quarter-final_375343.html" title="Fly-half went off after suffering head injuries in successive World Cup games." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/41/dan-biggar.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Wales' Dan Biggar sits injured on October 9, 2019" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/41/dan-biggar.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Wales' Dan Biggar sits injured on October 9, 2019" width="124" height="93" /></noscript><div
class="trending_title"> Warren Gatland insists Dan Biggar is fully fit for quarter-final</div> </a></div></div><div
id="subnav_cricket" class="subnav"><div
class="more_left"><div
class="subnav_col"> <strong>Explore Cricket</strong> <a
href="/cricket/news/">News</a> <a
href="/cricket/result/">Results</a> <a
href="/cricket/england/">England News</a> <a
class="last_subnav" href="/cricket/ashes/">The Ashes</a></div></div><div
class="subnav_trending"><h2>Trending Cricket Stories</h2> <a
href="/cricket/news/three-uae-players-charged-under-icc-anti-corruption-code_375185.html" title="The trio were withdrawn from the UAE's squad a couple of days ago." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/42/mohammad-naveed.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Mohammad Naveed pictured for UAE in 2015" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/42/mohammad-naveed.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Mohammad Naveed pictured for UAE in 2015" width="124" height="93" /></noscript><div
class="trending_title"> Three UAE players charged under ICC anti-corruption code</div> </a><a
href="/cricket/birmingham-phoenix/news/steve-smith-david-warner-costliest-players-in-the-hundred-draft_375134.html" title="Only 24 of the 239 foreign stars who have thrown their names into the hat will land a contract." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/37/steve-smith.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Steve Smith in action for Australia on September 13, 2019" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/37/steve-smith.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Steve Smith in action for Australia on September 13, 2019" width="124" height="93" /></noscript><div
class="trending_title"> Steve Smith, David Warner costliest players in The Hundred draft</div> </a><a
href="/cricket/england/news/chris-silverwood-anderson-and-morgan-can-decide-when-to-step-down_374809.html" title="Anderson will miss the tour of New Zealand with a calf injury." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/27/eoin-morgan.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="England's Eoin Morgan demonstrates what men have on June 30, 2019" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/27/eoin-morgan.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="England's Eoin Morgan demonstrates what men have on June 30, 2019" width="124" height="93" /></noscript><div
class="trending_title"> Chris Silverwood: 'Anderson and Morgan can decide when to step down'</div> </a><a
href="/cricket/england/news/andy-flower-steps-down-from-ecb-after-12-years_374775.html" title="The Zimbabwean had a successful stint as England head coach." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/41/andy-flower.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Andy Flower pictured in June 2017" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/41/andy-flower.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Andy Flower pictured in June 2017" width="124" height="93" /></noscript><div
class="trending_title"> Andy Flower steps down from ECB after 12 years</div> </a><a
href="/cricket/england/news/ashley-giles-concerned-for-ben-stokes-over-press-attention_374716.html" title="A photograph of an alleged confrontation between the player and his wife was published on Tuesday." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/37/ben-stokes_1.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Ben Stokes pictured during England nets on September 11, 2019" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/37/ben-stokes_1.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Ben Stokes pictured during England nets on September 11, 2019" width="124" height="93" /></noscript><div
class="trending_title"> Ashley Giles concerned for Ben Stokes over press attention</div> </a></div></div><div
id="subnav_formula-1" class="subnav"><div
class="more_left"><div
class="subnav_col"> <strong>Explore Formula 1</strong> <a
href="/formula-1/news/">News</a> <a
href="/formula-1/driver-rankings.html">Driver Rankings</a> <a
href="/formula-1/team-rankings.html">Team Rankings</a> <a
href="/motorsport/">Motorsport</a></div><div
class="subnav_col subnav_dropdown last_subnav"> <strong
class="last_subnav">Grands Prix</strong> <a
href="/formula-1/abu-dhabi-grand-prix/">Abu Dhabi GP</a> <a
href="/formula-1/brazilian-grand-prix/">Brazilian GP</a> <a
href="/formula-1/mexican-grand-prix/">Mexican GP</a> <a
href="/formula-1/united-states-grand-prix/">United States GP</a> <a
href="/formula-1/russian-grand-prix/">Russian GP</a> <a
href="/formula-1/japanese-grand-prix/">Japanese GP</a> <a
href="/formula-1/singapore-grand-prix/">Singapore GP</a> <a
href="/formula-1/italian-grand-prix/">Italian GP</a><a
class="last_subnav" href="/formula-1/british-grand-prix/">British GP</a></div></div><div
class="subnav_trending"><h2>Trending Formula 1 Stories</h2> <a
href="/formula-1/mclaren/news/mclaren-car-concepts-to-change-for-2020-seidl_375223.html" title="Andreas Seidl says McLaren needs to change &quot;some concepts&quot; of the car ahead of 2020." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/18/mclaren.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Carlos Sainz Jr in action for McLaren in April 2019" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/18/mclaren.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Carlos Sainz Jr in action for McLaren in April 2019" width="124" height="93" /></noscript><div
class="trending_title"> McLaren car 'concepts' to change for 2020 - Seidl</div> </a><a
href="/formula-1/formula-1-daily-roundups/news/thursdays-formula-1-news-roundup-russell-seidl-hamilton_375250.html" title="Here, Sports Mole rounds up the latest Formula 1 news on Thursday, October 17." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/42/george-russell.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="George Russell pictured on October 10, 2019" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/42/george-russell.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="George Russell pictured on October 10, 2019" width="124" height="93" /></noscript><div
class="trending_title"> Thursday's Formula 1 news roundup: Russell, Seidl, Hamilton</div> </a><a
href="/formula-1/red-bull/news/tost-wants-gasly-kvyat-to-stay-in-2020_375222.html" title="Franz Tost says he wants Pierre Gasly and Daniil Kvyat to remain at Toro Rosso in 2020." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/28/pierre-gasly.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Pierre Gasly pictured at the British GP on July 11, 2019" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/28/pierre-gasly.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Pierre Gasly pictured at the British GP on July 11, 2019" width="124" height="93" /></noscript><div
class="trending_title"> Tost wants Gasly, Kvyat to stay in 2020</div> </a><a
href="/formula-1/toro-rosso/news/f1s-future-still-shaping-up_375227.html" title="It is busy times for Formula 1 as the future of the sport continues to shape up." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/18/31/ross-brawn.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Ross Brawn at the Chinese GP in May 2017" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/18/31/ross-brawn.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Ross Brawn at the Chinese GP in May 2017" width="124" height="93" /></noscript><div
class="trending_title"> F1's future still shaping up</div> </a></div></div><div
id="subnav_american-football" class="subnav"><div
class="more_left"><div
class="subnav_col"> <strong>Explore NFL</strong> <a
href="/american-football/news/">News</a> <a
href="/american-football/nfl/standings.html">Standings</a> <a
href="/american-football/result/">Results</a> <a
href="/american-football/super-bowl/">Super Bowl</a> <a
href="/american-football/transfer-talk/">Transfer Talk</a> <a
href="/american-football/injury-news/">Injury News</a></div><div
class="subnav_col subnav_dropdown last_subnav"> <strong
class="last_subnav">Popular Teams</strong> <a
href="/american-football/dallas-cowboys/">Dallas Cowboys</a> <a
href="/american-football/green-bay-packers/">Green Bay Packers</a> <a
href="/american-football/new-york-giants/">New York Giants</a> <a
href="/american-football/pittsburgh-steelers/">Pittsburgh Steelers</a> <a
href="/american-football/new-england-patriots/">New England Patriots</a> <a
href="/american-football/chicago-bears/">Chicago Bears</a> <a
class="last_subnav" href="/american-football/san-francisco-49ers/">San Francisco 49ers</a></div></div><div
class="subnav_trending"><h2>Trending American Football Stories</h2> <a
href="/american-football/denver-broncos/result/result-kansas-city-chiefs-thrash-denver-broncos-despite-patrick-mahomes-injury_375340.html" title="Kansas City's star quarterback left the game with an injured knee in the second quarter." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/42/patrick-mahomes.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Kansas City Chiefs quarterback Patrick Mahomes (15) is helped off the field after a play in the second quarter against the Denver Broncos at Empower Field at Mile High on October 18, 2019" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/42/patrick-mahomes.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Kansas City Chiefs quarterback Patrick Mahomes (15) is helped off the field after a play in the second quarter against the Denver Broncos at Empower Field at Mile High on October 18, 2019" width="124" height="93" /></noscript><div
class="trending_title"> Result: Kansas City Chiefs thrash Denver Broncos despite Patrick Mahomes injury</div> </a><a
href="/american-football/houston-texans/result/result-packers-claim-dramatic-comeback-win-over-lions_375058.html" title="Green Bay had trailed 13-0 in the second quarter." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/42/mason-crosby.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Mason Crosby in action for the Packers on October 14, 2019" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/42/mason-crosby.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Mason Crosby in action for the Packers on October 14, 2019" width="124" height="93" /></noscript><div
class="trending_title"> Result: Packers claim dramatic comeback win over Lions</div> </a><a
href="/american-football/chicago-bears/news/tottenham-hotspur-stadium-hailed-after-first-year-of-hosting-nfl_374966.html" title="Carolina Panthers quarterback Kyle Allen described the venue as &quot;incredible&quot;." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/14/tottenham-hotspur-general.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="A general shot of the new Tottenham Hotspur Stadium on March 30, 2019" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/14/tottenham-hotspur-general.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="A general shot of the new Tottenham Hotspur Stadium on March 30, 2019" width="124" height="93" /></noscript><div
class="trending_title"> Tottenham Hotspur Stadium hailed after first year of hosting NFL</div> </a><a
href="/american-football/houston-texans/result/result-houston-texans-upset-kansas-city-chiefs_374952.html" title="Deshaun Watson trumps Patrick Mahomes in quarterback battle." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/42/tyreek-hill.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Tyreek Hill in action for Kansas City Chiefs on October 13, 2019" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/42/tyreek-hill.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Tyreek Hill in action for Kansas City Chiefs on October 13, 2019" width="124" height="93" /></noscript><div
class="trending_title"> Result: Houston Texans upset Kansas City Chiefs</div> </a></div></div><div
id="subnav_off-the-pitch" class="subnav"><div
class="more_left"><div
class="subnav_col"> <strong>Explore Off The Pitch</strong> <a
href="/off-the-pitch/news/">News Stories</a> <a
class="last_subnav" href="/off-the-pitch/video/">Video</a></div></div><div
class="subnav_trending"><h2>Trending Off The Pitch Stories</h2> <a
href="/off-the-pitch/news/paul-gascoigne-cleared-of-sexual-assault-on-train_375268.html" title="Paul Gascoigne cleared of sex assault but jury still considering beating charge" class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/18/34/paul-gascoigne.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Paul Gascoigne arrives for the Frampton fight on August 18, 2018" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/18/34/paul-gascoigne.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Paul Gascoigne arrives for the Frampton fight on August 18, 2018" width="124" height="93" /></noscript><div
class="trending_title"> Paul Gascoigne cleared of sexual assault on train</div> </a><a
href="/off-the-pitch/leeds-united/news/andrea-radrizzani-leeds-not-actively-seeking-investment_375232.html" title="The Italian previously claimed to have been approached &quot;by more than 20 parties&quot;." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/18/29/andrea-radrizzani.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Leeds United owner Andrea Radrizzani, pictured on February 10, 2018" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/18/29/andrea-radrizzani.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Leeds United owner Andrea Radrizzani, pictured on February 10, 2018" width="124" height="93" /></noscript><div
class="trending_title"> Andrea Radrizzani: 'Leeds not actively seeking investment'</div> </a><a
href="/off-the-pitch/bury/news/judge-adjourns-bury-winding-up-order_375167.html" title="The judge said he would reconsider the case on October 30." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/34/bury-gigg-lane_1.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Street sign pointing to Gigg Lane, home of Bury" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/34/bury-gigg-lane_1.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Street sign pointing to Gigg Lane, home of Bury" width="124" height="93" /></noscript><div
class="trending_title"> Judge adjourns Bury winding-up order</div> </a><a
href="/off-the-pitch/bulgaria/euro-2020/news/four-men-detained-in-bulgaria-over-racist-abuse-of-england-players_375162.html" title="Police in Sofia are continuing their search." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/42/tyrone-mings.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Tyrone Mings in action for England on October 14, 2019" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/42/tyrone-mings.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Tyrone Mings in action for England on October 14, 2019" width="124" height="93" /></noscript><div
class="trending_title"> Four men detained in Bulgaria over racist abuse of England players</div> </a><a
href="/off-the-pitch/celtic/europa-league/news/lazio-handed-partial-stadium-closure-against-celtic-after-racism_375161.html" title="The Serie A club have been charged with racist behaviour." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/33/neil-lennon.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Celtic manager Neil Lennon pictured on August 13, 2019" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/33/neil-lennon.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Celtic manager Neil Lennon pictured on August 13, 2019" width="124" height="93" /></noscript><div
class="trending_title"> Lazio handed partial stadium closure against Celtic after racism</div> </a></div></div><div
id="subnav_golf" class="subnav"><div
class="more_left"><div
class="subnav_col"> <strong>Explore Golf</strong> <a
href="/golf/news/">News</a> <a
href="/golf/result/">Results</a> <a
href="/golf/us-open-golf/">US Open</a> <a
href="/golf/masters/">The Masters</a> <a
href="/golf/ryder-cup/">Ryder Cup</a> <a
href="/people/rory-mcilroy/">Rory McIlroy</a> <a
class="last_subnav" href="/people/tiger-woods/">Tiger Woods</a></div></div><div
class="subnav_trending"><h2>Trending Golf Stories</h2> <a
href="/golf/news/phil-mickelson-i-dont-deserve-to-be-at-the-presidents-cup_375170.html" title="The 49-year-old is currently ranked 47th in the world." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/14/phil-mickelson.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Phil Mickelson in action on March 29, 2019" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/14/phil-mickelson.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Phil Mickelson in action on March 29, 2019" width="124" height="93" /></noscript><div
class="trending_title"> Phil Mickelson: 'I don't deserve to be at the Presidents Cup'</div> </a><a
href="/golf/news/tiger-woods-agrees-deal-to-write-memoir_375097.html" title="A release date for the book - entitled &quot;BACK&quot; - has yet to be confirmed." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/29/tiger-woods.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Tiger Woods pictured on July 19, 2019" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/29/tiger-woods.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Tiger Woods pictured on July 19, 2019" width="124" height="93" /></noscript><div
class="trending_title"> Tiger Woods agrees deal to write memoir</div> </a><a
href="/golf/news/henrik-stenson-annika-sorenstam-to-host-scandinavian-mixed-tournament_374968.html" title="Players from the European Tour and Ladies European Tour will compete for one trophy, which will be held in Sweden in June." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/18/39/henrik-stenson.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Henrik Stenson in action during day one of the Ryder Cup on September 28, 2018" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/18/39/henrik-stenson.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Henrik Stenson in action during day one of the Ryder Cup on September 28, 2018" width="124" height="93" /></noscript><div
class="trending_title"> Henrik Stenson, Annika Sorenstam to host Scandinavian Mixed tournament</div> </a><a
href="/golf/news/golfer-tyrrell-hatton-distracted-by-fiancee-slamming-toilet-door-during-shot_374702.html" title="The 27-year-old was competing in the Italian Open when he was interrupted." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/29/tyrrell-hatton.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Tyrrell Hatton pictured at The Open on July 18, 2019" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/29/tyrrell-hatton.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Tyrrell Hatton pictured at The Open on July 18, 2019" width="124" height="93" /></noscript><div
class="trending_title"> Golfer Tyrrell Hatton distracted by fiancee slamming toilet door during shot</div> </a><a
href="/golf/result/result-jon-rahm-storms-to-successful-madrid-title-defence_374226.html" title="The Spaniard finished 22 under par at Club de Campo." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/27/jon-rahm.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Jon Rahm in action at the Irish Open on July 7, 2019" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/27/jon-rahm.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Jon Rahm in action at the Irish Open on July 7, 2019" width="124" height="93" /></noscript><div
class="trending_title"> Result: Jon Rahm storms to successful Madrid title defence</div> </a></div></div><div
id="subnav_basketball" class="subnav"><div
class="more_left"><div
class="subnav_col"> <strong>Explore NBA</strong> <a
href="/basketball/news/">News</a> <a
href="/basketball/nba/standings.html">Division Standings</a> <a
href="/basketball/nba/conferences.html">Conference Standings</a> <a
href="/basketball/result/">Results</a> <a
href="/basketball/transfer-talk/">Transfer Talk</a> <a
href="/basketball/injury-news/">Injury News</a></div><div
class="subnav_col subnav_dropdown last_subnav"> <strong
class="last_subnav">Popular Teams</strong> <a
href="/basketball/la-lakers/">LA Lakers</a> <a
href="/basketball/chicago-bulls/">Chicago Bulls</a> <a
href="/basketball/boston-celtics/">Boston Celtics</a> <a
href="/basketball/new-york-knicks/">New York Knicks</a> <a
href="/basketball/miami-heat/">Miami Heat</a> <a
href="/basketball/golden-state-warriors/">Golden State Warriors</a> <a
class="last_subnav" href="/basketball/san-antonio-spurs/">San Antonio Spurs</a></div></div><div
class="subnav_trending"><h2>Trending Basketball Stories</h2> <a
href="/basketball/brooklyn-nets/transfer-talk/news/kevin-durant-to-join-brooklyn-nets_363422.html" title="The NBA star made an announcement via Instagram account The Boardroom." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/18/kevin-durant.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Golden State Warriors forward Kevin Durant (35) celebrates against the Houston Rockets during the second quarter in game one of the second round of the 2019 NBA Playoffs at Oracle Arena on April 28, 2019" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/18/kevin-durant.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Golden State Warriors forward Kevin Durant (35) celebrates against the Houston Rockets during the second quarter in game one of the second round of the 2019 NBA Playoffs at Oracle Arena on April 28, 2019" width="124" height="93" /></noscript><div
class="trending_title"> Kevin Durant to join Brooklyn Nets</div> </a><a
href="/basketball/milwaukee-bucks/news/giannis-antetokounmpo-named-as-nbas-mvp-for-2018-19_362901.html" title="He saw off competition from last year's winner James Harden." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/17/giannis-antetokounmpo.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Giannis Antetokounmpo in actionn for Milwaukee Bucks onn April 22, 2019" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/17/giannis-antetokounmpo.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Giannis Antetokounmpo in actionn for Milwaukee Bucks onn April 22, 2019" width="124" height="93" /></noscript><div
class="trending_title"> Giannis Antetokounmpo named as NBA's MVP for 2018-19</div> </a><a
href="/basketball/la-lakers/news/new-orleans-pelicans-land-zion-williams-in-nba-draft_362560.html" title="It comes after the Pelicans agreed to trade Anthony Davis to the Los Angeles Lakers." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/25/zion-williams.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Zion Williams pictured at the NBA Draft on June 20, 2019" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/25/zion-williams.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Zion Williams pictured at the NBA Draft on June 20, 2019" width="124" height="93" /></noscript><div
class="trending_title"> New Orleans Pelicans land Zion Williams in NBA Draft</div> </a><a
href="/basketball/golden-state-warriors/result/result-toronto-raptors-defeat-golden-state-warriors-to-seal-first-nba-title_361979.html" title="The Raptors overcame the Warriors 114-110 to take the best-of-seven series 4-2, despite Golden State coming close to forcing a seventh game." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/24/torgsw.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Toronto Raptors guard Kyle Lowry (7) lifts up the Larry O'Brien Championship Trophy after being Golden State Warriors for the NBA Championship in game six of the 2019 NBA Finals at Oracle Arena on June 14, 2019" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/24/torgsw.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Toronto Raptors guard Kyle Lowry (7) lifts up the Larry O'Brien Championship Trophy after being Golden State Warriors for the NBA Championship in game six of the 2019 NBA Finals at Oracle Arena on June 14, 2019" width="124" height="93" /></noscript><div
class="trending_title"> Result: Toronto Raptors defeat Golden State Warriors to seal first NBA title</div> </a></div></div><div
id="subnav_boxing" class="subnav"><div
class="more_left"><div
class="subnav_col"> <strong>Explore Boxing</strong> <a
href="/boxing/news/">News</a> <a
href="/boxing/result/">Results</a> <a
href="/people/anthony-joshua/">Joshua vs. Klitschko</a> <a
href="/wwe/">WWE</a> <a
href="/ufc/">UFC</a> <a
class="last_subnav" href="/wrestling/">Wrestling</a></div></div><div
class="subnav_trending"><h2>Trending Boxing Stories</h2> <a
href="/boxing/news/tearful-eddie-hearn-urges-boxing-to-do-more-in-wake-of-patrick-day-death_375338.html" title="The death of Patrick Day shows boxing should be made safer, promoter Eddie Hearn says." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/42/patrick-day.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Patrick Day (red trunks) reacts after getting knocked down by Charles Conwell (not pictured) during a USBA Super-Welterweight boxing match at Wintrust Arena on October 13, 2019" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/42/patrick-day.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Patrick Day (red trunks) reacts after getting knocked down by Charles Conwell (not pictured) during a USBA Super-Welterweight boxing match at Wintrust Arena on October 13, 2019" width="124" height="93" /></noscript><div
class="trending_title"> Tearful Eddie Hearn urges boxing to do more in wake of Patrick Day death</div> </a><a
href="/boxing/news/boxer-patrick-day-dies-aged-27-after-sustaining-head-injuries-in-fight_375214.html" title="Day underwent brain surgery following his bout against Charles Conwell." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/42/patrick-day.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Patrick Day (red trunks) reacts after getting knocked down by Charles Conwell (not pictured) during a USBA Super-Welterweight boxing match at Wintrust Arena on October 13, 2019" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/42/patrick-day.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Patrick Day (red trunks) reacts after getting knocked down by Charles Conwell (not pictured) during a USBA Super-Welterweight boxing match at Wintrust Arena on October 13, 2019" width="124" height="93" /></noscript><div
class="trending_title"> Boxer Patrick Day dies aged 27 after sustaining head injuries in fight</div> </a><a
href="/boxing/news/carl-frampton-eager-to-move-on-from-horrific-year_375098.html" title="The 32-year-old suffered a broken hand earlier this year." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/18/51/carl-frampton.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Carl Frampton pictured on December 19, 2018" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/18/51/carl-frampton.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="Carl Frampton pictured on December 19, 2018" width="124" height="93" /></noscript><div
class="trending_title"> Carl Frampton eager to move on from "horrific year"</div> </a><a
href="/boxing/feature/everything-you-need-to-know-about-tyson-furys-foray-into-wwe_374965.html" title="Fury is fighting Braun Strowman at a WWE Crown Jewel event in Saudi Arabia." class="trending"> <img
class="lazy most_popular_picture" src="https://sm.imgix.net/11/29/1x1.gif?w=1&h=1" data-original="https://sm.imgix.net/19/37/tyson-fury_1.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="A bloodied Tyson Fury in action on September 14, 2019" width="124" height="93" /><noscript><img
class="most_popular_picture" src="https://sm.imgix.net/19/37/tyson-fury_1.jpg?w=124&h=93&auto=compress,format&fit=clip" alt="A bloodied Tyson Fury in action on September 14, 2019" width="124" height="93" /></noscript><div
class="trending_title"> Everything you need to know about Tyson Fury's foray into WWE</div> </a></div></div><div
id="subnav_more-sports" class="subnav"><div
class="more_left"><div
class="subnav_col"> <strong>Explore More Sports</strong> <a
href="/american-football/">American Football</a><a
href="/archery/">Archery</a><a
href="/athletics/">Athletics</a><a
href="/aussie-rules/">Aussie Rules</a><a
href="/badminton/">Badminton</a><a
href="/baseball/">Baseball</a><a
href="/basketball/">Basketball</a><a
href="/beach-volleyball/">Beach Volleyball</a></div><div
class="subnav_col"><br
/><a
href="/boccia/">Boccia</a><a
href="/canoeing/">Canoeing</a><a
href="/cycling/">Cycling</a><a
href="/darts/">Darts</a><a
href="/disability-sports/">Disability Sports</a><a
href="/diving/">Diving</a><a
href="/equestrian/">Equestrian</a><a
href="/esport/">esports</a></div><div
class="subnav_col"><br
/><a
href="/fencing/">Fencing</a><a
href="/goalball/">Goalball</a><a
href="/greyhound/">Greyhound</a><a
href="/gymnastics/">Gymnastics</a><a
href="/handball/">Handball</a><a
href="/hockey/">Hockey</a><a
href="/ice-hockey/">Ice Hockey</a><a
href="/judo/">Judo</a></div><div
class="subnav_col"><br
/><a
href="/karate/">Karate</a><a
href="/lawn-bowls/">Lawn Bowls</a><a
href="/modern-pentathlon/">Modern Pentathlon</a><a
href="/motocross/">Motocross</a><a
href="/motorsport/">Motorsport</a><a
href="/netball/">Netball</a><a
href="/other/">Other</a><a
href="/racing/">Racing</a></div><div
class="subnav_col"><br
/><a
href="/rowing/">Rowing</a><a
href="/rugby-league/">Rugby League</a><a
href="/rugby-union/">Rugby Union</a><a
href="/sailing/">Sailing</a><a
href="/sambo/">Sambo</a><a
href="/shooting/">Shooting</a><a
href="/snooker/">Snooker</a><a
href="/squash/">Squash</a></div><div
class="subnav_col"><br
/><a
href="/surfing/">Surfing</a><a
href="/swimming/">Swimming</a><a
href="/table-tennis/">Table Tennis</a><a
href="/taekwondo/">Taekwondo</a><a
href="/trampoline/">Trampoline</a><a
href="/triathlon/">Triathlon</a><a
href="/ufc/">UFC</a><a
href="/volleyball/">Volleyball</a></div><div
class="subnav_col"><br
/><a
href="/water-polo/">Water Polo</a><a
href="/weightlifting/">Weightlifting</a><a
href="/wheelchair-rugby/">Wheelchair Rugby</a><a
href="/winter-sports/">Winter Sports</a><a
href="/wrestling/">Wrestling</a><a
class="last_subnav" href="/wwe/">WWE</a></div></div></div></div></div><div
id="endjs"></div> <script type="text/javascript">var newsArray=new Array();var SMcountDownDate = "October 18, 2019 19:45";</script> <div
class="BottomSpace">&nbsp;</div></body></html>', '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