<p><span class="anfang">T</span>raditionsenligt avgörs det stora sprinterloppet Criterium de Vitesse två veckor efter styrkeprovet Prix de Paris och sätter på sätt och vis punkt för elithästarnas vintersäsong i Frankrike.</p>
<p>Precis som vanligt kryllar det av toppnamn i detta klassiska lopp. Prix d&#8217;Amerique-favoriten <strong>Etonnant</strong> är på jakt efter sin första Grupp I-seger för året och var stor i nederlaget i Prix de Paris. Här kan det bli en sevärd duell mot <strong>Vivid Wise As</strong> som är obesegrad i Cagnes-sur-Mer efter fem försök och som har två raka inteckningar i just Criterium de Vitesse i ryggen.</p>
<p><em>Som vanligt är det jackpot på söndagens High Five-spel och potten är sockrad med tio miljoner kronor!</em></p>
<h2>Snabbanalys:</h2>
<p><strong>8 Vivid Wise As</strong> har aldrig förlorat i Cagnes-sur-Mer efter fem försök. Han vann Prix de France i senaste starten, var dessförinnan fyra i Prix d&#8217;Amerique och är än mer gynnad av dessa förutsättningar med sprinterdistans. <strong>6 Etonnant</strong> ser vi som det stora hotet. Han gjorde ett jättelopp mellan två galopper i fjolårets upplaga av Criterium de Vitesse trots att han tävlade med skor den dagen och i år blir det barfota runt om! <strong>5 Delia du Pommereux</strong> var tvåa i motsvarande lopp ifjol och visade äntligen uppryckning senast i Prix de France. <strong>3 Cokstile</strong> är kraftigt gynnad av dessa förutsättningar liksom <strong>1 Zacon Gio</strong>, men den sistnämnde inleder från ett startspår från vilket det är väldigt svårt att ta ledningen i Cagnes-sur-Mer.</p>
<p><em>Under vinjetten djupanalys längre ner på denna sida kan du läsa en fullständig loppanalys med ranking och kommentarer om samtliga hästar!</em></p>
<p><strong>Spela High Five ihop med Sulkysports samarbetspartners:</strong></p>
<h2>MyWay Skoghall</h2>
<p><a href="https://spela.svenskaspel.se/spela-tillsammans/ombudslag/22539-andelonline---myway-skoghall/spel/1471791/2511510?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/2505725?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>
<h2>Café Brasco</h2>
<p><a href="https://spela.svenskaspel.se/spela-tillsammans/ombudslag/22370-cafe-brasco/spel/1337739/2510077?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/2510088?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/2510082?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>Djupanalys:</h2>
<p><strong>Criterium de Vitesse (€200.000)</strong><a href="https://sulkysport.se/wp-content/uploads/2022/03/skarmavbild20220312kl.18.36.07.png"><img class="aligncenter wp-image-276573 size-sulky-storst2" src="https://sulkysport.se/wp-content/uploads/2022/03/skarmavbild20220312kl.18.36.07-1280x1111.png" alt="" width="1280" height="1111" /></a></p>
<ul>
<li><strong>8 Vivid Wise As</strong> har vunnit de två senaste upplagorna av detta lopp, är obesegrad i Cagnes-sur-Mer efter fem starter och kommer bli favorit i det här loppet. Det känns naturligt när han lämnat så färska formbesked som han gjort genom fjärdeplatsen i Prix d’Amerique samt den övertygande segern i Prix de France där Matthieu Abrivard läste loppet helt rätt och valde att spara speeden istället för att köra från start eller lägga en speed mitt i loppet. Skulle han skicka med full kraft utifrån spår åtta finns chansen att han får ta över från Cokstile eller Billie de Montfort och annars blir hans primära mål att försöka undvika dödens.</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 />
8 Vivid Wise As<br />
6 Etonnant</p>
<p><strong>B-hästar</strong><br />
5 Delia du Pommereux<br />
3 Cokstile<br />
1 Zacon Gio</p>
<p><strong>C-hästar</strong><br />
4 Billie de Montfort<br />
13 Alcoy<br />
2 Bahia Quesnot<br />
7 Vitruvio<br />
9 Dreammoko<br />
11 Belff Dipa<br />
10 Elsa de Belfonds<br />
12 Desir de Bannes							</div>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>
<ul>
<li><strong>6 Etonnant</strong> var strålande som knappt slagen tvåa i Prix de Paris efter att fått lägga flera speeder under vägen. Han var med i det här loppet ifjol och stod för en insats som många säkerligen glömt bort. Först galopperade hästen hejdlöst direkt från start och därefter fick han ett blytungt upplägg med tredjespår utan rygg resterande del av loppet! Trots det såg han stark ut innan han blev störd till galopp vid upploppets början och vi tror faktiskt att han hade varit tvåa eller trea i mål annars. Richard Westerink har varit oerhört nöjd med sin häst en längre period och då hovarna tycks hålla för att köra barfota även denna gång så förväntar vi oss ännu en toppinsats från åttaåringen.</li>
<li><strong>5 Delia du Pommereux</strong> var fyra i det här loppet 2020 och slutade tvåa bakom Vivid Wise As i fjolårets upplaga. Hon hade ryggen på just Vivid Wise As i senaste starten vilken ägde rum i Prix de France, men var chanslös att utmana honom över upploppet även om hon gick bra som tvåa. Ska hon få revansch på den italienska storstjärnan så kan det krävas att hon sitter före honom i fältet när det drar ihop sig för upploppet och inte behöver ha längder som ska plockas in.</li>
<li><strong>3 Cokstile</strong> vann Prix de Bourgogne via spets- och släpp till Vivid Wise As i början av januari. Han var tillbaka på medeldistans senast i Prix de France och var lite av en ”surrhäst” i det loppet, men den speed han fick lägga halvvägs in i loppet för att nå ledningen satte sina spår och nioåringen var slagen i slutkurvan. Nu är han åter ute över den distans på vilken han vann Elitloppet 2020 och vi har oerhört stort respekt för hur Erik Bondo kan ställa i ordning sina hästar till viktiga lopp såsom detta.</li>
<li><strong>1 Zacon Gio</strong> är tillbaka på italiensk mark under Holger Ehlerts beskydd efter en vinter hos Jean-Michel Bazire. Resultaten var verkligen blandade, men några noterbara toppar gick att skönja såsom tredjeplatsen i senaste starten som ägde rum i Prix de France. Sprinterdistans är den här rusarens likör, men däremot är han inte lika förtjust i långa upplopp. Det är lätt att tro att spår ett är perfekt för denna startsnabba häst, men anloppet vid lopp över 1.609 meter i Cagnes-sur-Mer blir kort då bilen släpper fältet tajt efter kurvan och vi tror inte att han frontar av egen kraft.</li>
<li><strong>4 Billie de Montfort</strong> gör sin femte raka start i det här loppet! Hon har aldrig vunnit, men var tvåa bakom Bold Eagle 2018, trea 2020 och fyra ifjol. På ålderns höst är hon inte alls särskilt pigg på att tävla på Vincennes utmanande bankropp utan de här förutsättningarna med platt bana och sprinterdistans är hennes melodi. Spår fyra bakom bilen är ett perfekt utgångsläge i Cagnes-sur-Mer och vi blir inte ett dugg förvånade om hon kommer förbi såväl Zacon Gio som Cokstile direkt. Att hon ska köras i ledningen utesluter vi, men en fin, invändig smygresa ger henne chansen att ta en placering bland de fem främsta och därtill körs hon av sin gamla vapendragare Eric Raffin för första gången sedan den 15 maj 2019!</li>
<li><strong>13 Alcoy</strong> gick jättebra som tvåa i Prix de Luxembourg och vann därefter Grupp III-klassade Prix Pierre Desire Allaire i just Cagnes-sur-Mer. Den dagen handlade det om lång distans och han löste uppgiften från tät, men på ålderns höst uppfattar vi hästen allra vassast över kortare distanser. Alcoy är en duktig spurtare som var sexa i det här loppet ifjol samt fyra i Grand Prix du Departement des Alpes-Mari i augusti på rekordnoteringen 1.09,9 så det känns inte alls otänkbart att han får med sig en bit av priskakan även här.</li>
<li><strong>2 Bahia Quesnot</strong> gör sin fjärde raka start i detta lopp. Hon var trea såväl 2019 som 2021 medan 2020 års resultat uppgick till en sjundeplats. Vid båda tredjeplatserna tävlade hon barfota runt om och vid sjundeplatsen var det skor runt om som gällde. Just skor är det på hovarna i årets upplaga och då det inte slagit gnistor om stoet i vintern sulkylopp så ger vi henne begränsade möjligheter att slåss om tätplatserna detta år.</li>
<li><strong>7 Vitruvio</strong> trodde vi var mer eller mindre slut som sulkyhäst, men Alessandro Gocciadoro har gjort ett starkt arbete med hingsten. Efter tredjeplatsen i finalen av Gran Premio della Lotteria i höstas så slutade hästen femma i Prix de France i senaste starten efter att kommit ner i invändigt smygläge. Lyckas han kopiera det upplägget är det inte omöjligt att Vitruvio får med sig en bra bit av priskakan även denna gång.</li>
<li><strong>9 Dreammoko</strong> har en andraplats i Gran Premio della Lotteria samt en fjärdeplats i Elitloppet på sitt cv. Efter en svag fjolårssäsong så flyttades hästen till Claus Hollman i Italien och vid debuten i hans regi stod hästen för en riktigt vass avslutning som tvåa, om än i betydligt enklare sällskap. Spår nio borgar för en invändig, spårsnål väg fram till mål och vi ser fram emot att se vad Dreammoko kan uträtta i det här loppet.</li>
<li><strong>11 Bleff Dipa</strong> skickades till tät i Criterium Continental för att släppa och satt faktiskt lite fast över målgången som fyra bakom vinnaren Hohneck. Han har inte varit lika vass i de efterföljande två starterna, men då har det handlat om lång distans och 1.609 meter är klart mer gynnsamt för denna häst som vann finalen av det italienska derbyt som femåring.</li>
<li><strong>10 Elsa de Belfonds</strong> lyckades nypa femteplatsen i det här loppet ifjol trots att hon tävlade med skor på hovarna den dagen och var även trea i Grand Prix Departement des Alpes-Mari i Cagnes-sur-Mer på rekordnoteringen 1.09,8 i augusti. Då som nu tävlade hon barfota runt om vilket är ett klart plus och hon är ett tänkbart skrällbud för någon av de nedre High Five-placeringarna.</li>
<li><strong>12 Desir de Bannes</strong> gör debut för Nicolas Ensch efter att tidigare tävlats av Herve Sionneau. Nioåringen har ett begränsat cv kontra sina konkurrenter och när han därtill ska tävla med skor runt om så är han självklar jumbohäst i vår rank.</li>
</ul>
