<p>Veckans V75-omgång hämtas från Halmstad och givetvis är det den tredje deltävlingen till Paralympiatravet (V75-7) som tilldrar sig störst uppmärksamhet.</p>
<p>Det är ett starkt startfält som gör upp om direktplatsen, men hemmalagets stjärnor har sannerligen inte fått någon fördel i spårtombolan. <strong>Cyber Lane</strong>, <strong>Zarenne Fas</strong>, <strong>Heart Of Steel</strong> samt <strong>Aetos Kronos</strong> dyker upp från bricka sju, nio, tio samt tolv så någon &#8221;hemmalottning&#8221; går det inte att prata om här i alla fall&#8230;</p>
<p>Omgången känns smålömsk och de där riktigt givna singelstrecken lyser med sin frånvaro vid en första anblick.</p>
<p>Kanske blir <strong>Wingait Henke</strong> (V75-2) omgångens största favorit i klass II-försöket och mycket tyder på att han vinner loppet om han inte blir över från start och blir fastlåst.<br />
Så blev fallet vid karriärens hittills enda förlust så ska konkurrenterna fälla honom lär de få rikta in sig på att kopiera det upplägget.</p>
<p><a href="https://sulkysport.se/wp-content/uploads/2021/04/24v75.pdf" target="_blank" rel="noopener noreferrer">Här kan du ta del av lördagens startlistor.</a></p>
<h2>Avd 1 – Silverdivisionen, 2.140 meter voltstart</h2>
<p>Inte allra högsta klass på silverdivisionen denna vecka och kanske är det så enkelt att flera stått över att anmäla på grund av att det är voltstart? <strong>Vikens High Yield </strong>startade på Bergsåker i lördags så här blir det täta starter, men det brukar ju oftast Robert Berghs hästar klara av. Sjuåringen felade kort efter start, men stod för en stark upphämtning och var med klungan fint in till mål. Han blir betrodd här liksom <strong>Royal Navy Neo </strong>som inlett året med två raka segrar på övertygande vis. Hästen har sett bättre ut nu än han gjorde i höstens starter och klarar även av att anfalla bakifrån. <strong>Beartime </strong>galopperade bort en trolig andraplats i silverfinalen i slutet av mars. Han tar omtag här från öppet spår, är sannolikt spetshästen och kan bli svårstoppad. Spontant så höjer sig de här tre rätt så rejält över mängden.</p>
<h2>Avd 2 – Klass II, 2.140 meter autostart</h2>
<p>Visste vi att <strong>Wingait Henke </strong>skulle hålla upp innerspåret så hade vi spikat utan att tveka, men det känns inte som en garanti att han lyckas med den saken. Fyraåringen såg jättefin ut senast på Åby då han fick löpa ut i tät och vid karriärens enda förlust satt han fast i vinnarhålet och fick inte se dagens ljus. Han kan säkert gå en låg 1.13-tid vid behov, men som sagt; frågan är hur det blir här från innerspåret? <strong>Digital Eye </strong>gick ett bra lopp i just klass II på Romme den 4 april och avgjorde snyggt i ett tempostarkt lopp på Solvalla gången innan. <strong>Pre Calculated </strong>gillar vi skarpt, men det känns ofta som han hamnar lite illa till i loppen och det lär inte bli lättare nu från spår åtta. <strong>Crank </strong>gick bra i skymundan senast på Romme och <strong>Yuvaraj </strong>avslutade strålande i skymundan i klass II-finalen på Solvalla.</p>
<h2>Avd 3 – Diamantstoet, 2.140 meter voltstart</h2>
<p>Man kan givetvis tänka att det här loppet är så enkelt så att <strong>Domingoa </strong>bara spårar hem det likt på Jägersro, men man ska ha i åtanke att han går upp i klass nu och att det är tuffare ston som jagar henne. Dessutom finns det några dugliga utmanare på grunddistansen såsom <strong>Eye in theSky D.K.</strong> som har två segrar, en andra- och en tredjeplats sedan tidigare på svensk mark. Från 40 meters tillägg testar Fredrik Persson åter med <strong>Ultra Bright </strong>som var chanslös i senaste Diamantstofinalen trots att hon avslutade 1.10,3 sista varvet! Hennes chanser i sådana här typ av lopp är alltid avhängda av att det blir tempo och det känns inte helt givet att det kommer bli det här samtidigt som banan lär bli självspringande om vädret är bra. <strong>Grande Diva Sisu </strong>på samma volt svarade för en oväntat bra årsdebut, men även hon är avhängd av hur loppet artar sig. <strong>Belen Hall Fas </strong>var strålande som tvååring, men inte lika vass som treåring även om hon blev trea i italienska Oaksfinalen. Hon står tufft inne här och vi tror inte hon kliver ut och vinner direkt i debuten för Jerry Riordan.</p>
<h2>Avd 4 – Ungdomslopp, 2.140 meter autostart</h2>
<p>Den fina fuman <strong>Kali Smart </strong>hade vi inga större förväntningar på i årsdebuten då hon stod med tillägg, men insatsen som trea den dagen var faktiskt riktigt vettig. Hon lär gå framåt med det loppet i kroppen och har fin chans att överta ledningen av <strong>La Mauresque </strong>här som vi inte tror körs i ledningen denna gång heller med tanke på att det här loppet känns lite tuffare än det hon var tvåa i på V75 senast. <b>Artemide Zack </b>har varit jättebra i två raka segrar och klarar av flera olika typer av upplägg. Att hon därtill körs av sin ordinarie kusk är en fördel, men frågan är om 2.140 meter är detsamma? <strong>Zante Grif </strong>var strong som höll emot i Påskägget i Gävle och lyckades vinna det loppet på banrekord. Nu är förutsättningarna annorlunda, men hon vann lopp bakifrån under fjolåret på svensk mark så det i sig är inget som hindrar henne. Den här trion sticker ut och lär bli klart mer betrodda än de övriga.</p>
<h2>Avd 5 – Klass I, 3.140 meter autostart</h2>
<p>Det ger verkligen en extra krydda med lopp över tre varv inom STL och denna gång är det klass I-hästarna som ska ställas inför den utmaningen. <strong>Bara du Chene </strong>vann ett B-tränarlopp inom V75 på Färjestad under långfredagen. Det blev ganska tuff körning i det loppet så trots att han inledde i tredje ledet flöt det på bra, men sättet han avgjorde på tar vi verkligen med oss. Hästen har utvecklats så mycket under en längre period att han ska vara favorit här. <strong>Aragorn As </strong>fick en tuff väg fram till dödens på Deal Done Zet i Gävle. Han fick även släppa Fighter Lady förbi sig sista biten, men det behöver man sannerligen inte be om ursäkt för. Trots spår tolv är han en faktor att räkna med här. <strong>Elephant </strong>har tre segrar på sju starter på svensk mark och aldrig varit sämre än trea på denna sidan sundet. <strong>Starbec&#8217;s A.to Z.</strong> är anmäld barfota runt om denna gång. Hästen var bland annat femma i ett Europaderbykval på den balansen i höstas och kan vara en jättefidus här då spår åtta faktiskt går att leva med när loppet körs 3.140 meter.</p>
<h2>Avd 6 – Bronsdivisionen, 1.640 meter autostart</h2>
<p>Ett lurigt bronsförsök där det kan gå undan värre från start. <strong>Zaffiro Jet </strong>vann i klassen på Åby i början av mars. Man stod över finalen på Solvalla och man gjorde sannolikt det för att hästen inte skulle gå ur den här klassen utan kunna gå med full kraft för det här loppet som också är över sprint. Man drog vinstlotten spårmässigt, men frågan är om Nicklas Korfitsen vågar gambla här och släppa tät nu när det inte finns någon &#8221;reservplan&#8221; á la open stretch att tillgå? <strong>Bordeaux S.</strong> fick inte till det i Frankrike under vintern, men var jättefin i återkomsten i Halmstad, om än mot ganska enkla hästar. Högkapable <strong>Istanbul Boko</strong> såg &#8221;sjövild&#8221; ut senast på Solvalla. Han gjorde en jättebra upphämtning, men måste sköta sig nu om han ska få med något av kakan. <strong>Zinko Top </strong>höll bra från dödens i debuten på svensk mark och <strong>Te Amo Corazon </strong>gör intressant debut i Björn Goops regi. Han skickar ut hästen i ett sådant här sammanhang direkt i årsdebuten och vi kan inte tolka det på annat sätt än att han är nöjd med fjolårets norska Derbytrea.</p>
<h2>Avd 7 – Paralympiatravet, deltävling 3, 2.140 meter autostart</h2>
<p>Med toppnamn som <strong>Cyber Lane</strong>, <strong>Zarenne Fas </strong>och <strong>Aetos Kronos </strong>på svåra startspår så är det svårt att säga annat än att det ska vara fördel för <strong>Handsome Brad </strong>i det här loppet. Han var inte på topp i finalen senast på Solvalla, men samtidigt gestaltade sig inte loppet på bästa sätt för hans del utan han fick göra allt jobb själv i tredjespår på slutrundan och det blev för tufft. Nu tyder mycket på att han når ledningen av egen kraft. Ja, så till vida att inte <strong>Chief Orlando </strong>tar sig förbi då för här pratar vi ju om en riktig startraket. Hästen vann bland annat Gran Premio Palio Dei Comuni i Montegiorgio i höstas och i årsdebuten kom han aldrig riktigt till från tredje invändigt även om det kanske inte slog gnistor om hästen. Körande Vincenzo Gallo är 27 år gammal och har tagit för sig allt mer på senare år på italiensk mark, men är väldigt färsk i sådana här sammanhang och ska han kunna vinna loppet så gäller det nog att han får en bra position direkt. Nämnda Cyber Lane och Riordans duo Zarenne Fas samt Aetos Kronos är givetvis bra nog för att segerstrida, men startspåren är ofta väldigt avgörande i de här loppen så frågan är hur offensivt upplägg det blir på de här hästarna denna gång?</p>
