<p>Noll. Det är antalet fransksfödda, fransktränade hästar som har vunnit Paralympiatravet – eller Olympiatravet som loppet hette förr – genom åren.</p>
<p>Måhända har de varit för märkta av ett tufft vintermeeting och loppet har kommit fel i kalendern då de ofta varit för slitna denna period på året, men det har också gjort att flera franska toppar helt enkelt stått över loppet och istället fokuserats mot vila och avelsarbete.</p>
<p>I år har Åbys travbanechef Jon Walter Pedersen lyckats locka en osedvanligt het fransk duo i form av Prix de France-segrarinnan <strong>Delia du Pommereux</strong> och den hungriga, femåriga uppstickare <strong>Gelati Cut</strong> så nu har de verkligen chansen att bryta den negativa trenden.</p>
<p>Därtill körs hästarna av rutinerade, internationellt meriterade kuskar som vet hur man tar för sig i de här sammanhangen så det franska laget känns starkt.</p>
<p>Hela V75-omgången – och loppen dessförinnan – är en enda stor kavalkad av toppsport och det går inte göra annat än att längta efter lördagens topptävlingar.</p>
<p><a href="https://sulkysport.se/wp-content/uploads/2021/05/08v75.pdf" target="_blank" rel="noopener noreferrer">Här kan du ta del av lördagens startlistor till Åby.</a></p>
<h2>Avd 1 – Drottning Silvias Pokal, 2.140 meter autostart</h2>
<p>Det ska vara klar fördel för försöksvinnarna i finalen av Drottning Silvias Pokal. <strong>Eagle Eye Sherry</strong> står inför exakt samma förutsättningar som hon gjorde i just försöket och hon ska vara favorit till att leda det här loppet från start till mål. <strong>Honey Mearas</strong> har fått två ögonöppnare i Daniel Redéns regi och det märks att man har stor tro på att det här stoet är lite extra. <strong>Fifty Cent Piece</strong> var jättebra i försöket och verkar klara av att gå hela vägen in till mål även på svensk mark. <strong>Namaste</strong> är en bubblare som kommer underifrån med lite egenheter, men stort kunnande. Det känns svårt att hitta någon övrig häst som känns riktigt het och vi säger klar fördel för de nämnda och då i synnerhet Eagle Eye Sherry.</p>
<h2>Avd 2 – Klass II, 2.140 meter voltstart</h2>
<p>Ett riktigt roligt Klass II-lopp med hästar som är födda i sju olika länder. Cash Gambles halvbror <strong>Donato Frecel</strong> har tagit tid på sig, men verkligen kommit igång starkt nu som fyraåring. Vi uppfattar honom som en häst med betydligt mer i sig än vad han sprungit tidsmässigt och kan se honom blir svårslagen om han håller upp innerspåret. Christian Fiores <strong>Beckham</strong> kan mycket väl vara bästa hästen och han är dessutom tuff. Ett bakspår i volten kan vara gynnsamt för den här hästen då ett öppet spår skulle kunna göra honom väl vass när det ska rusas iväg. <strong>Unacerveza Broline</strong> var jättefin i Kalmar och räcker bra bara han klarar av täta starter. <strong>Cadiz</strong> är stark, men hinner han med över medeldistans mot så här kvalificerat motstånd?</p>
<h2>Avd 3 – Konung Gustaf V:s Pokal, 2.140 meter autostart</h2>
<p>Med <strong>Brambling</strong> struken är det fördel för <strong>Önas Prince</strong> i Kungakannan. Han såg precis lika fin ut som tidigare vid försöksvinsten och mycket tyder på att han vinner starten. Frågan är dock hur pass bra <strong>Wild West Diamant</strong> kan vara om han lyckas hålla upp vinnarhålet? Hästen stod för en dunderinsats i försöket där han vann trots att han fick jobba i spåren och nu kan det bli vinnarhålet om Rick Ebbinge får rätt snurr på hästen initialt. <strong>Rome Pays Off</strong> förväntar vi oss kommer lyfta ytterligare till finalen och <strong>Maesteraemon</strong> var verkligen ett utropstecken i försöket, men det känns ändå tufft för den duon att räcka hela vägen till seger.</p>
<h2>Avd 4 – Klass I, 1.640 meter autostart</h2>
<p>Trond Anderssen och Kristian Malmin har fått en häftig snurr på <strong>Z.Boko</strong> som kommer från en häftig seger på 1.12,7a/2.140 meter på Sörlandet. Vinner han starten kan loppet vara över, men här kan det gå undan initialt. <strong>Alpago W.F. </strong>visade prov på god startsnabbhet vid debutsegern på svensk mark. Han är sannerligen inte missgynnad av kort distans och kan vinna på flera olika sätt. Bara du Chene känns mer stark än snabb, men gick bra efter galopp i Halmstad och kommer verkligen till start med formen i topp. Lägesgynnade <strong>Bone Hard Flash</strong> och Flemming Jensens segermaskin <strong>Billi Time</strong> – som förvisso svek vid senaste Klass I-testet – är också värda att nämna.</p>
<h2>Avd 5 – Bronsdivisionen, 2.640 meter autostart</h2>
<p>Ett riktigt kul bronsförsök över lång distans där det är många om budet vid en första anblick. <strong>Rackham</strong> kommer stärkt med två lopp i kroppen och fjolårets Breeders Crown-finalist ska nog vara favorit här från ett bra utgångsläge. <strong>Easy Cash</strong> är dock en värdig utmanare. Hästen har helt rätt kurva och verkligen övertygat i Robert Berghs regi. <strong>Arvid S.H.</strong> väntar alltjämt på sin första STL-seger efter två andra- och två tredjeplatser. Nu körs han av Örjan Kihlström för första gången. <strong>Uncle Töll</strong> gick jättebra i sin årsdebut och lär knappast vara sämre med det loppet i kroppen. André Eklundh har toppform på sitt stall. <strong>Usain Töll</strong> var blek i debuten för Mattia Orlando och fjolårets Sprintermästar- och Derbyfinalist måste lyfta markant för att kunna hävda sig mot de här hästarna. Blir spår tolv för besvärligt för fine <strong>Oracle Tile</strong>? Mycket talar för det när det finns dubbla open stretch att tillgå och &#8221;alla&#8221; kommer få chansen&#8230;</p>
<h2>Avd 6 – Lovely Godivas Minne, 2.140 meter autostart</h2>
<p>Normalt sett ska detta var en mycket passande uppgift för <strong>Milady Grace</strong>, men det faktum att han galopperade i mål (förvisso som etta) i årsdebuten lämnar en del övrigt att önska och det fanns även starter i fjol då hon föll ifrån. Fjolåets norska Derbystovinnare <strong>Lucky Queen Soa</strong> skulle kunna hålla upp innerspåret initialt, men tar knappast emot varken Milady Grace eller <strong>Allegra Gifont</strong>. Den sistnämnda gjorde en superbra debut på svensk mark i Travkompaniets Jubileumslopp bakom Short In Cash och blir inte lätt att besegra om hon kommer först vilket faktiskt är möjligt med tanke på hennes startsnabbhet. Per Nordström har varit väldigt tydlig med att det är nu som <strong>Grande Diva Sisu</strong> ska &#8221;explodera&#8221; och spår nio behöver inte alls vara fel för det här speediga stoet som nu har två lopp i kroppen.</p>
<h2>Avd 7 – Paralympiatravet, 2.140 meter autostart</h2>
<p>Med <strong>Ecurie D.</strong> på spår åtta så har verkligen spekulationerna inför Paralympiatravet öppnats upp och blivit livliga. Hamre-brödernas häst ska givetvis räknas för alla vet vilken topphäst detta är, men han kommer verkligen inte till dukat bord. <strong>Aetos Kronos</strong> var &#8221;dunder&#8221; vid sin försöksvinst även om det var flera betrodda som föll ifrån den dagen. <strong>Gelati Cut</strong> har testat på tävling på platta banor mot tuffa hästar på italiensk mark och stått sig väl mot toppar. Han är en given utmanare från ett perfekt utgångsläge. <strong>Delia du Pommereux</strong> går egentligen kräva ska vara i toppslag nu med tanke på hennes långa och framgångsrika vinter, men vi gillade vad vi såg från henne i Prix d&#8217;Atlantique och tror verkligen att Eric Raffin kommer att &#8221;gå för det&#8221; i det här loppet.<strong> Who&#8217;s Who</strong> som verkar ännu vassare i år och <strong>Very Kronos</strong> är givetvis tidiga bud likaså även om genrepet för den sistnämnde lämnade en del övrigt att önska.</p>
