<p>Halmstads Sprintermästarhelg ser ut att bjuda på en smålurig lördagsomgång. Vi säger inte att utdelningen kommer sticka iväg på samma sätt som den gjorde på Färjestad i lördags, men de där givna spikarna vill vi påstå lyser med sin frånvaro och här kommer det krävas jobb under veckan för att bena ut både det ena och det andra.</p>
<p>Kanske ändå att hemmahoppet <strong>Cyber Lane</strong> (V75-3) kommer bli omgångens största favorit i Gulddivisionen. Johan Untersteiners häst har inte startat sedan han blev sjua i Elitloppsförsöket, men har rent historiskt gjort bra lopp efter uppehåll och står med passande förutsättningar från innerspår bakom bilen samtidigt som han har den värsta spetskonkurrent tätt intill sig.</p>
<p>Avslutningen blir spännande då spelarna ska spekulera i om <strong>Chicharita</strong> och <strong>Kali Smart</strong> (V75-7) kan bära de 300.000 kronor de båda fick på sig från deras senaste seger.</p>
<p><a href="https://sulkysport.se/wp-content/uploads/2021/07/10v75.pdf" target="_blank" rel="noopener">Här kan du ta del av lördagens startlistor till tävlingar i Halmstad.</a></p>
<h2>Avd 1 – Silverdivisionen, 2.140 meter voltstart</h2>
<p>För ovanlighetens skull startas silverloppet med voltstart. Därmed känns inte andraspår optimalt för <strong>Zio Tom Jet</strong> som vann silverloppet i Kalmar från tät utan här kan det bli problem direkt och det är inte givet att han går iväg. <strong>Vikens High Yield</strong> agerar ojämnt. Näst senast i Östersund gjorde hästen en toppinsats, men i lördags på Färjestad hände det inte mycket när han fick chansen efter en avvaktande löpning. Det är möjligt att Robert Bergh inte brukade hästen för fullt och att det kommer hända mer denna gång. <strong>Racing Ribb</strong> kördes offensivt i Kalmar innan han blev avlöst. Hästen blev fast med sparade krafter och lär laddas friskt från springspår. <strong>Can Lane</strong> felade direkt i Östersund, men har gått strålande innan det. Med minsta klaff rundar han många, kanske alla.</p>
<h2>Avd 2 – Wången Cup, final – 2.140 meter autostart</h2>
<p>Ett riktigt lurigt lopp där det känns som att i princip vad som helst kan hända och det är i skrivande stund omöjligt att spekulera i vilken häst som kommer få bära på favoritskapet. <strong>Condior</strong> hade varit med ytterligare något hack längre fram senast i Boden om han inte hade krokat ihop med en konkurrent 500 meter före mål. Vid tokladdning är det inte omöjligt att det kan bära hela vägen till ledningen denna gång. <strong>Lucky Truc</strong> kördes avvaktande i comebacken i torsdags, men såg fin ut över upploppet när han fick sträcka ut. Hästen var på väg mot en V75-seger i lag med just Victor Rosleff på Åby i början av februari innan galoppen kom 150 meter före mål. <strong>Mystic Mom</strong> har spurtat bra tre starter i följd, men även om detta är en spårtrappa så känns det väldigt besvärligt att stå i tredje ledet bakom vingen. Som sagt; vidöppet!</p>
<h2>Avd 3 – Gulddivisionen, 2.140 meter autostart</h2>
<p><strong>Cyber Lane</strong> var jättefin då han spårade hem Copenhagen Cup, men hade inte sin bästa dag i Elitloppet. Nu har han pausat i sex veckor, men hästen brukar gå bra efter uppehåll och bör ha chans att kunna hålla ut <strong>Stepping Spaceboy</strong> när de står sida vid sida. <strong>Heart of Steel</strong> bet i bra över upploppet i Kalmarsundspokalen trots att han såg slagen ut i slutkurvan. Han missgynnas inte av medeldistans, men behöver lite klaff på den här nivån för att räcka till vinst. Forfantone Am har återigen fått ett bra läge och kan slå till om han får spara speeden. <strong>Short In Cash</strong> har återfallit i gamla galoppsynder två starter i följd. Han kan vara gynnad av att inleda i andra ledet för att lirkas iväg felfri och vad det gäller formen finner vi ingen anledning att tro att det är fel på det området utan snarare verkar hästen vara lite väl laddad för dagen.</p>
<h2>Avd 4 – Klass I, 2.640 meter voltstart</h2>
<p>Ett mycket bra Klass I-försök där det finns en handfull hästar som man normalt sett tippar etta i ett sådant här lopp utan att blinka. <strong>Flirting Diamond</strong> gjorde en mycket bra insats som trea i Klass II-finalen under Elitloppshelgen trots att han fick göra grovjobbet själv. Nu blir det lite långt mellan starterna och det oroar oss spontant med tanke på kvalitén på konkurrenterna denna gång för här går det knappast att snora ut och vara 90-procentig. <strong>Encore Cloc</strong> har övertygat i två segrar i Steen Juuls regi och det känns som att han står väldigt billigt inne i klassen. <strong>Ol Dono Lengai</strong> ströks på grund av halsinfektion i Harper Hanovers lopp, men studsade snabbt tillbaka och vann comebacken i Berlin under midsommarhelgen. Han har visat förut att han hävdar sig väl på svensk mark. <strong>Jaxon V.S.</strong> var bra i Vaggeryd och även vid segern senast på Jägersro, men här kan det vara några som är för tuffa för honom. <strong>Dream Creation</strong> är en vass spurtade som visade form senast i Mantorp där han slog banrekord.</p>
<h2>Avd 5 – Klass II, 2.140 meter autostart</h2>
<p><strong>Amalencius B.B.</strong> höll stången från ledningen senast i Lindesberg. Han bör vara en häst som ska kunna duga även i sådana här sammanhang och givetvis ökar chansen då han står som spetsfavorit även här. <strong>Howdy Quick</strong> tror vi är bästa hästen i fältet. Han gjorde ett topplopp i Kalmar där det blev tredjespår utan rygg sista varvet, men likväl inkom han som trea. Innerspår bakom bilen känns dock inte optimalt för hans del utan här kan han bli rejält över från början. <strong>Versace Broline</strong> stod verkligen på tur och var värd segern senast i Kalmar. Nu steppar Joakim Lövgren upp och låter hästen göra Klass II-debut, men vi har egentligen ingen anledning att tro att Versace Broline ska få problem här. <strong>Global Beware</strong> är också bra och det känns verkligen som att det är hästarna med de fyra innersta spåren som ska göra upp om det här loppet.</p>
<h2>Avd 6 – Bronsdivisionen, 1.640 meter autostart</h2>
<p>Här kan det gå undan initialt. <strong>Astonacente Zac</strong> fungerade inte som bäst i Boden utan försvann ur loppet redan efter 150 meter. Här har han viss chans att hålla upp ledningen och från den positionen lyfter hästen flera klasser. <strong>Laradja Vrijthout</strong> är den stora utmanaren initialt. Han bombade till tät i Kalmar och höll riktigt bra med tanke på att det blev en tuff öppning över full väg. <strong>Rackham</strong> skulle också varit med på Smålandsbanan, men ströks på grund av feber. Han är ingen utmanare från början, men jättebra när han får gå i draget och fuxen har alla möjligheter att vinna det här loppet om det blir minsta överpacat. <strong>Quite E.Wood</strong> har äntligen fått ett bra utgångsläge och känns spelmässigt som loppets mest intressanta häst medan <strong>Oscar L.A.</strong> blir motsatsen från spår åtta trots kanoninsatsen i Kalmar där han gick gå i tredjespår sista 1.300 meterna!</p>
<h2>Avd 7 – Diamantstoet, 2.640 meter autostart</h2>
<p>Smålurig avslutning där det står två hästar i andra och tredje ledet som samlat på sig snabba prispengar. Vi tänker dels på <strong>Chicharita</strong> som vann ett större femåringslopp för ston senast på Vermo och fick knappt 300.000 kronor på ett bräde. Hon har sex raka segrar nu och det finns egentligen ingenting som säger att hon inte ska kunna bära prispengarna, men det är klart att uppgiften är tuff från spår tolv i en spårtrappa på en snabb bana.<strong> Kali Smart</strong> gjorde en dunderinsats i Fyraåringseliten för ston på en tid som där och då var nytt svenskt rekord. Hon samlade likt Chicharita på sig en rejäl sudd på ett bräde och samma sak gäller för henne att det här blir en utmaning att reda ut. Bland framspårshästarna känns <strong>Greta Sisu</strong> intressant. Hon har lyft i Roni Paldans regi och med ett lopp i främre träffen – helst med ryggar – kommer hon gå fort över upploppet. <strong>Gitte Silvåkra</strong> har bra startryggar och är en så pass stark spurtare att hon absolut kan hävda sig i det här loppet.</p>
