<p>Fyra av hästarna från förra veckans Gulddivisionslopp dyker upp även denna lördag där Romme står som värd för V75-spelet och däribland topptrion från det loppet!</p>
<p>Ovanligt värre och kanske lite extra anmärkningsvärt med tanke på att banan i lördags var allt annat än lättsprungen och såg ut att resultera i stumma ben för flera av de aktuella hästar.</p>
<p><strong>Disco Volante</strong> (V75-3) får starta från bricka sju den här veckan och med startsnabba hästar på insidan så ställs han verkligen inför en prövning.</p>
<p>Omgångens två största favoriter tror vi oss finna i mellanavdelningarna. Daniel Redéns <strong>D.Day Zet</strong> (V75-4) och Daniel Wäjerstens <strong>Algot Zonett</strong> (V75-5) lär båda bli hårt betrodda i klass II respektive silverdivisionen då de står inför lämpliga uppgifter och därtill har vettiga utgångslägen.</p>
<p><a href="https://sulkysport.se/wp-content/uploads/2021/02/27v75.pdf" target="_blank" rel="noopener noreferrer">Här kan du ta del av lördagens startlistor till Romme.</a></p>
<h2>Avd 1 – Klass I, 2.140 meter voltstart</h2>
<p>En häftig inledning där det verkligen är många om budet. Det ska bli hyperintressant att se <strong>She&#8217;s Ready</strong> i det här sammanhanget och det känns glädjande att Marie Hafstad Eriksson väljer att köra sin häst själv även i STL-sammanhang. Det går att argumentera för att han inte mött de värsta gängen vid segrarna, men hästen har sett närmast okörd ut varje gång. <strong>Enge Eros </strong>har gjort två starter efter uppehåll och kurvan pekar uppåt. Fjärdespår i voltstart kan dock bli ett problem. <strong>Red Hot Roadster </strong>kommer från spetstriumf, men spurtade starkt bakifrån i starten innan och går från alla positioner. <strong>Power Blaster </strong>var duktig tvåa bakom Demon Ima i klass II-finalen. <strong>Tullibardine Boe </strong>stämde det inte alls för positionsmässigt senast, men hon såg fin ut i skymundan. <strong>Artful Deimos </strong>skrällvann på Åby, men får tuffare här när han studsat upp i klass. Totalt sett ett riktigt öppet lopp.</p>
<h2>Avd 2 – Kallblodsdivisionen, 2.140 meter voltstart</h2>
<p><strong>B.W.Rune </strong>tog ner <strong>Roli Eld </strong>från utsidan vid deras senaste möte i Bollnäs och det är självklart att han ska vara favorit i det här loppet utifrån den insatsen. Därtill har han visat toppform i starterna dessförinnan och det är uppenbart att sexåringen är på väg att ta steget och etablera sig som en riktig, riktig topphäst. <strong>Alfie </strong>fick välförtjänt utdelning i torsdags då hon vann på nytt banrekord i Gävle. Det känns dock tufft för henne att hålla undan 20 meter på topparna som jagar där bakom. <strong>Emil Mollyn </strong>var trea i Lars Laumbs lopp på Bjerke i lördags vilket likt detta race innehöll flera starka toppar.</p>
<h2>Avd 3 – Gulddivisionen, 1.640 meter autostart</h2>
<p>Vi har svårt att tro att <strong>Evaluate</strong> ska kunna upprepa sin skrällseger från i lördags nu när han drog bricka tolv över sprint. I lördags var <strong>Disco Volante</strong> tung favorit, men han gick sig trött efter en halvsnabb inledning på den svårbemästrade banan. Nu drog han spår sju och har startsnabba hästar på insida så den här uppgiften känns inte helt enkel. <strong>Hazard Boko </strong>är i toppslag, men det kan bli svårt att komma förbi <strong>Giveitsgasandgo </strong>om Wilhelm Paal bestämmer sig för att köra den hästen i ledningen. <strong>Zenit Brick </strong>galopperade i första kurvan i lördags, men gick bra i starten innan. Kan han bli den som avgör om inledningstempot blir högt?</p>
<h2>Avd 4 – Klass II, 2.140 meter autostart</h2>
<p><strong>D.Day Zet</strong> kan mycket väl bli omgångens största favorit på lördag. Han har inlett året med två spetssegrar och även om det går att argumentera för att de är tagna i rätt så enkla sammanhang och kanske inte sagt så mycket så har hästen gett ett tilltalande intryck. Här är motståndet något annat, men vi köper helt klart honom som favorit. <strong>Again Kronos</strong> fanns tidigare i just Daniel Redéns regi, men huserar numera hos Jonna Irri och har lyft på finsk mark. Hästen avlade sitt maiden på Vermo i senaste starten efter en snygg 600 metersrepa från andra utvändigt och Muscle Hill-sonen står överkomligt inne i det här loppet. Kapable <strong>Global Above All </strong>lär inte varit supervässad inför återkomsten, men avgjorde likväl via ett rejält slutvarv. Det kommer han behöva prestera även här för att kunna vinna från spår tolv. <strong>Zeolit </strong>gick en stark upphämtning efter galopp senast på Solvalla, men kanske riskerar den att sitta i benen nu när det blir tätt startande.</p>
<h2>Avd 5 – Silverdivisionen, 2.640 meter autostart</h2>
<p>Algot Zonett höll starkt som dödenstvåa i silverfinalen och kommer kunna fortsätta tävla i den här klassen ett bra tag till. Han känns verkligen som den tuffaste hästen i det här sällskapet för dagen och kommer bli svårslagen även om han får svar om Daniel Wäjersten avser att vara offensiv och försöka trycka sig till tät. <strong>Sign Me Up Too </strong>var tapper dödenstvåa på Bergsåker och följde upp med en enkel spetsvinst i Bollnäs. Han är av rätt sort och står distansen, men Algot Zonett känns formstarkare för dagen. Hedershästen <strong>Donners Am </strong>gör sällan ett dåligt lopp och vi har inte haft något alls att anmärka på hans senaste silverinsatsen även om det inte räckt hela vägen. <strong>Global Undecided </strong>såg väl trög ut senast på Solvalla, men gynnas av att det är ett varv längre distans denna gång. Allt blev helt fel för <strong>Carat du Goutier </strong>senast på Färjestad när han fick svar under anfall, men den här uppgiften känns i vilket fall tuff för hans del.</p>
<h2>Avd 6 – Diamantstoet, 2.640 meter voltstart</h2>
<p>Ett relativt svagt Diamantstoförsök och därtill inte helt lättlöst. <strong>Donna Leonora </strong>har verkligen gått bra i sina Solvallastarter. Senast fick hon alldeles för långt fram, men avslutade jättebra till andraplatsen. Hon klarade av ett snävt startspår i Eskilstuna och bör ha hygglig chans att åtminstone få andra- eller tredje utvändigt initialt. Visste vi att <strong>Pappajonnys Ilse </strong>var tillbaka i rätt form och kunde hålla upp ledningen från innerspår så hade detta sett spännande ut, men hon var mer än lovligt blek i återkomsten på Romme. <strong>Smaragd Norrgård </strong>höll okej som spetstrea senast på Solvalla. Kanske väljer man att släppa ledningen denna gång när det handlar om lång distans? <strong>Zooropa </strong>fortsätter att leverera starka insatser för jämnan och vi vet att hon tål distansen. Av tilläggshästarna är hon den som spontant känns hetast. Vad kan <strong>Heavenly May </strong>hitta på med ett invändigt smyglopp och luckan in mot upploppet?</p>
<h2>Avd 7 – Bronsdivisionen, 2.140 meter autostart</h2>
<p><strong>Global Winner </strong>fick en tuff inledning senast på Solvalla, men stod pall för den och visade att han är tillbaka i rätt form. Allt tyder på att han är i sådant slag att han ska vara mogen att leverera även inom STL-sammanhang på nytt. <strong>Oxidizer </strong>vann från dödens på Åby. Hästen såg lysande ut den dagen och trots att han nu gör debut i bronsdivisionen så måste vi tro att han kan hävda sig även här. <strong>Balotelli Crown </strong>flög fram i spurten i Gävle och kan bli något av lördagens bubblare på spelet från ett perfekt utgångsläge. <strong>Mas Capacity </strong>har det stämt bra för positionsmässigt i de två senaste starterna och då har han också gjort riktigt starka insatser. För oss känns han gynnad av att gå invändigt och dit blir det svårt att nå från det här utgångsläget. <strong>Dark Roadster </strong>avslutade förvisso bra senast på Solvalla, men vi tror att han behövt ett bättre utgångsläge för att kunna räcka här.</p>
