<p><span class="anfang">T</span>raditionsenligt avgörs Prix de Luxembourg dagen före Prix d&#8217;Amerique och årets upplaga håller riktigt bra klass efter ett par år av svagare versioner.</p>
<p>Svenskintresset är stort då det finns blågul koppling i åtta av de 16 deltagarna. Såväl vi som de franska tipsexperterna är rörande överens om att det är Daniel Redéns <strong>Missle Hill</strong> och Jerry Riordans <strong>Gareth Boko</strong> som har störst vinstchans av de svensktränade hästarna och duon får därtill franska toppkuskar bakom sig i form av Franck Nivard och Eric Raffin.</p>
<p>De två hästarna tar plats i vår A-grupp som totalt utgörs av fyra hästar, men vi placerar Jean-Michel Bazires<strong> Elie de Beaufour</strong> först. Valacken möter ett tuffare gäng denna gång, men vi finner ingen anledning att tro att han ska vara &#8221;kort i rocken&#8221;.</p>
<p><em>Du har nu chansen att spela andelsspel på High Five ihop med Sulkysports samarbetspartners enligt nedanstående alternativ:</em></p>
<h2>MyWay Skoghall</h2>
<p><a href="https://spela.svenskaspel.se/spela-tillsammans/ombudslag/22539-andelonline---myway-skoghall/spel/1471791/2331127?origin=/hitta-andelsspel" target="_blank" rel="noopener">Bas – 5 andelar á 60 kr/styck – Klicka här för att köpa andel</a></p>
<h2>Hemköp City Torget Kungsbacka</h2>
<p><a href="https://spela.svenskaspel.se/spela-tillsammans/ombudslag/35600-hemkop-city-torget-kungsbacka/spel/1270479/2328647?origin=/hitta-andelsspel" target="_blank" rel="noopener">Lilla original – 6 andelar á 88 kr/styck – Klicka här för att köpa andel</a></p>
<p><a href="https://spela.svenskaspel.se/spela-tillsammans/ombudslag/35600-hemkop-city-torget-kungsbacka/spel/1270482/2328649?origin=/hitta-andelsspel" target="_blank" rel="noopener">Stora original – 7 andelar á 151 kr/styck – Klicka här för att köpa andel</a></p>
<h2>Café Brasco</h2>
<p><a href="https://spela.svenskaspel.se/spela-tillsammans/ombudslag/22370-cafe-brasco/spel/1337739/2327127?origin=/hitta-andelsspel" target="_blank" rel="noopener">Lilla – 4 andelar á 75 kr/styck – Klicka här för att köpa andel</a></p>
<p><a href="https://spela.svenskaspel.se/spela-tillsammans/ombudslag/22370-cafe-brasco/spel/1337742/2327125?origin=/hitta-andelsspel" target="_blank" rel="noopener">Stora – 4 andelar á 149 kr/styck – Klicka här för att köpa andel</a></p>
<p><a href="https://spela.svenskaspel.se/spela-tillsammans/ombudslag/22370-cafe-brasco/spel/1337781/2327126?origin=/hitta-andelsspel" target="_blank" rel="noopener">Mega – 10 andelar á 106 kr/styck – Klicka här för att köpa andel</a></p>
<h2>Loppanalys:</h2>
<p><strong>Prix de Luxembourg (€100.000)</strong><a href="https://sulkysport.se/wp-content/uploads/2022/01/skarmavbild20220128kl.10.15.39.png"><img class="size-sulky-stor2 wp-image-263312 aligncenter" src="https://sulkysport.se/wp-content/uploads/2022/01/skarmavbild20220128kl.10.15.39-938x968.png" alt="" width="938" height="968" /></a></p>
<ul>
<li><strong>6 Elie de Beaufour</strong> kom fram perfekt som andrahäst halvvägs in i Prix du Forez för två veckor sedan. Bakom hårddragande Fire Cracker kunde Jean-Michel Bazire vänta med attacken tills slutkurvan och även om Elie de Beaufour slog av lite på takten sista biten så var segern aldrig hotad på topptiden 1.11,1/2.700 meter. Faktum är att stjärnvalacken bara haft framspår i autostart vid två tillfällen under de senaste 27 månaderna (!) och då har han inte alls öppnat särskilt snabbt från spår två på Vincennes och det gör att han blir svåranalyserad positionsmässigt i detta lopp. Att det är en häst i toppform vet vi dock med bestämdhet och vi köper honom som favorit i det här loppet. I synnerhet när hästen åter startar barfota runt om; en balans på vilken han har tio segrar och en andraplats på elva försök!</li>
</ul>
<div class="factbox right ">
<div class="insidefactbox">
<div class="overflow">
<div class="height">
<div class="padding">
<div class="factvinjett">Fakta</div>
<h3 class="title">
									RANKING								</h3>
<div class="content">
								<strong>A-hästar</strong><br />
6 Elie de Beaufour<br />
10 Missle Hill<br />
5 Feliciano<br />
2 Gareth Boko</p>
<p><strong>B-hästar</strong><br />
3 Alcoy<br />
11 Global Trustworthy<br />
4 Express Jet<br />
7 Fakir du Lorault<br />
1 Eclat de Gloire<br />
16 Fire Cracker<br />
15 Dear Friend</p>
<p><strong>C-hästar</strong><br />
9 Brillant Madrik<br />
14 Amon You Sm<br />
13 Calle Crown<br />
12 Wild Love<br />
8 Colonel							</div>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>
<ul>
<li><strong>10 Missle Hill</strong> hamnade helt ”åt råttorna” i Prix de Bourgogne från spår 17 bakom bilen, men stod för en formidabel avslutning vilket räckte till sjätteplatsen. Daniel Redén har haft siktet inställt mot denna helg därefter och det kittlar tveklöst att Franck Nivard sitter upp bakom sjuåringen som verkligen hittar ”rätt stigar” på kolstybben och även kört framgångsrikt åt Redén sedan tidigare. Sjuåringen inleder från det innersta spåret i bakre ledet vilket kan vara en smula lömskt och det är svårt att sia med bestämdhet om hur Missle Hill hamnar till positionsmässigt.</li>
<li><strong>5 Feliciano</strong> var en ”surrhäst” i det avslutande B-loppet Prix de Belgique, men hamnade bara djupare och djupare ner i fältet ju längre loppet gick. Då spelade det ingen roll att han avslutade tredje snabbast av alla de sista 500 meterna utan toppspurten gav blott en femteplats i utdelning. Visst ska Feliciano kunna blanda sig i segerstriden i det här loppet, men han har faktiskt inte vunnit lopp sedan den 16 juli 2020 och emellanåt har vi känt oss lite tveksamma till hans kämpatakter när det stått och vägt i slutskedet. David Thomain är i vilket fall mycket duktig på att ge sina styrningar moralstärkande vägar fram till upploppet och Felicano bör sluta bland de tre främsta.</li>
<li><strong>2 Gareth Boko</strong> var riktigt fin då han spurtade hem finalen av Gulddivisionen under annandag jul. Elitloppstrean har tävlat på skor i de två senaste starterna, men nu får han gå barfota runt om på nytt vilket givetvis är ett plus. Faktorer som bevisad form, perfekt utgångsläge och Eric Raffin i sulkyn gör Gareth Boko till en given segerkandidat och vi tillägger dessutom att Gareth Boko har en tredjeplats med sig i bagaget sedan tidigare på just Vincennes.</li>
<li><strong>3 Alcoy</strong> har tävlat med skor respektive barfota bak i sina två starter denna vinter, men nu blir det barfota runt om. Den svenskfödde åttaåringen gjorde faktiskt ett riktigt dugligt lopp senast i Cagnes-sur-Mer från tillägg och det känns därtill som att kortare distanser faller honom mer i smaken nu när han kommit upp lite i ålder. Vi förväntar oss en toppinsats av Martens-brödernas häst i detta lopp som bör kunna hamna vettigt till trots att han inte är någon blixt bakom bilen.</li>
<li><strong>11 Global Trustworthy</strong> blev snuvad på ledningen av Dear Friend när han gjorde comeback i Prix de Lille. Det kostade en del kraft för honom att ta över i skede två varpå första 1.100 meterna öppnades på 1.08,7 och in mot upploppet tröt krafterna. Med tanke på det tävlingsuppehåll hästen hade haft dessförinnan så är det rimligt att tro att han kan gå framåt till denna start. Vid finalsegern i Grupp I-klassade Palio dei Comuni i november kördes hästen på väntan och hann fram via en svettig spurt så hästen är inte golvad av att inleda i andra ledet.</li>
<li><strong>4 Express Jet</strong> stämde det inte alls för senast i Prix de Belgique där han blev dragen bakåt av en trött konkurrent, men när luckan uppenbarade sig sköt han till vasst som fyra. Det kommer säkert bli en hel del surr om Express Jet i det här loppet utifrån det positiva intrycket, men vi tycker inte att han är någon riktig hjälte utan är i behov av att få loppet lite serverat. I fransk media är han femte mest betrodd i loppet, men vi har honom alltså lite lägre.</li>
<li><strong>7 Fakir du Lorault</strong> fick ingenting med sig från de inledande två B-loppen och galopperade därefter i kön 200 meter före mål i Prix Jean Dumouch. I full form hade den här hästen känts högaktuell, men vinterintrycket har som sagt inte varit det rätta och hästen har inte fått något lopp i kroppen på sex veckor.</li>
<li><strong>1 Eclat de Gloire</strong> visade knallform under hösten i Tour Francais och vann såväl ett försök på Mallorca som finalen i belgiska Mons. Eclat de Gloire har gjort 16 starter på Vincennes och aldrig varit sämre än sexa vilket är intressant ur High Five-hänseende, men däremot har det bara blivit en seger på kolstybben. I lördags var det ett renodlad preparélopp på skor medan det är barfotabalans denna gång och utgångsläget borgar för att Eclat de Gloire ska få spara sin speed.</li>
<li><strong>16 Fire Cracker</strong> drog iväg med 1.11,1 de första 2.200 meterna i Prix du Forez och det var inte konstigt att han fick se sig besegrad av Elie de Beaufour som hade smugit fram i hans rygg halvvägs in i loppet och blivit perfekt framdragen. Den här gången gör Fire Cracker karriärens blott andra start över medeldistans och till skillnad från det föregående, misslyckade försöket (oplacerad) så sker det barfota runt om istället för på skor. Utgångsläget är uselt, men att Fire Cracker orkar hålla ångan uppe i högt tempo över 2.100 meter har han tydliggjort. Eric Raffin har valt bort hästen till förmån för Gareth Boko och nu körs sjuåringen av Benoît Robin för första gången.</li>
<li><strong>15 Dear Friend</strong> bombade till tät i Prix de Lille och släppte till Global Trustworthy. Hon fick chansen och höll farten bra som tvåa, men var långt efter vinnaren Feydeau Seven i mål. Nu blir det tätare starter och Dear Friend trivs fantastiskt bra på Vincennes där hon har två segrar och tre andraplatser på sex försök, men från bakspår har hon inte vunnit lopp på svensk mark sedan den 4 juli 2019. I de efterföljande fem loppen där hon inlett i andra ledet på svensk mark har hon som bäst slutat trea respektive åtta.</li>
<li><strong>9 Brillant Madrik</strong> galopperade direkt från start i Prix du Forez för två veckor sedan och gav oss inget formbesked den dagen. Backar vi bandet till Prix Jean Boillereau den 9 december så besegrade han stora delar av detta fält trots en del spår på vägen innan han slank ner i bra ”spurtposition”, men det känns som det är fler konkurrenter här som är ”påslagna” än vad som var fallet på förhand den gången. Från spår nio bakom bilen riskerar han att bli förlorare i positionskriget.</li>
<li><strong>14 Amon You Sm</strong> avslutade mycket positivt från kön i Prix Jean Boillereau näst senast, men fick se sig frånsprungen trots en perfekt invändig smygare i efterföljande Prix Tenor de Baune. Han gynnas av den kortare distans som gäller här, men står tveklöst inför en tuff utmaning från det här utgångsläget.</li>
<li><strong>13 Calle Crown</strong> återkom nyligen efter sju veckors tävlingsuppehåll. Han hamnade långt bak den dagen och var ute i vida spår när galoppen kom 250 meter före mål. Hästen såg inte trött ut i det skedet och ”norsken” var oryckt. Det är ett rimligt antagande att hästen flyttar fram formen med den ögonöppnaren innanför västen, men det kan bli långt fram på nytt från bakspår.</li>
<li><strong>12 Wild Love</strong> har inte visat någon storform i vinter och därtill dragits med halsinfektioner i omgångar. Harper Hanovers-vinnaren förväntas inte vara i storslag ännu och placeras utifrån det i bottenträsket i vår rank.</li>
<li><strong>8 Colonel</strong> har radat upp segrar hemma i Holland och sett fin ut, men det har varit i betydligt enklare omgivningar än vad som nu är fallet. Det ska sägas att han var tvåa bakom Eclat de Gloire i Tour Francais i oktober, men det här loppet har en helt annan bredd än vad startfältet hade den dagen och uppgiften känns övermäktig för Colonel.</li>
</ul>
